コード例 #1
0
ファイル: InputFile.cs プロジェクト: UIILabsDev/CodeJam
        public InputFile(string filePath)
        {
            using (var file = File.OpenText(filePath))
            {
                var testCaseCount = int.Parse(file.ReadLine());

                testCases = new List<TestCase>(testCaseCount);

                for (var i = 0; i < testCaseCount; i++)
                {
                    var kn = ReadInts(file);
                    var keys = ReadInts(file);

                    var N = kn[1];
                    var chests = new Chest[N];

                    for (var j = 0; j < N; j++)
                    {
                        var tokens = ReadInts(file);
                        chests[j] = new Chest(j + 1, tokens[0], tokens.Skip(2));
                    }

                    testCases.Add(new TestCase(keys, chests));
                }
            }
        }
コード例 #2
0
ファイル: Trove.cs プロジェクト: ajlopez/TddRocks
        public IList<int> GetSolution()
        {
            var chest = new Chest(0, this.keys.Keys.ToList());
            chest.Open();
            this.chests.Insert(0, chest);
            var count = this.chests.Count;
            var result = new int[count];

            int pos = 1;

            if (GetSolution(count, pos, result))
                return result;

            return null;
        }
コード例 #3
0
ファイル: Strategy.cs プロジェクト: UIILabsDev/CodeJam
        public Strategy OpenChest(Chest chest)
        {
            var keyIndex = Array.IndexOf(keysInHand, chest.RequiredKey);
            Debug.Assert(keyIndex >= 0);

            var newKeysInHand =
                keysInHand
                .Where((key,idx) => idx != keyIndex)
                .Concat(chest.ContainedKeys);
            Debug.Assert(newKeysInHand.Count() == keysInHand.Count() - 1 + chest.ContainedKeys.Count());

            var newOpenedChests =
                openedChests.Concat(Enumerable.Repeat(chest, 1));
            Debug.Assert(newOpenedChests.Count() == openedChests.Count() + 1);

            var newClosedChests =
                closedChests.Where(x=>x != chest);
            Debug.Assert(newClosedChests.Count() == closedChests.Count() - 1);

            return new Strategy(newKeysInHand, newOpenedChests, newClosedChests);
        }
コード例 #4
0
ファイル: Strategy.cs プロジェクト: UIILabsDev/CodeJam
        private void RecursivelyOpenChests(HashSet<Chest> scannedChests, Chest chest)
        {
            if (scannedChests.Contains(chest)) return;

            scannedChests.Add(chest);

            var openableChests = ClosedChests.Where(x=>chest.ContainedKeys.Contains(x.RequiredKey));

            foreach (var nextChest in openableChests)
                RecursivelyOpenChests(scannedChests, nextChest);
        }
コード例 #5
0
ファイル: Trove.cs プロジェクト: ajlopez/TddRocks
 public void AddChest(Chest chest)
 {
     this.chests.Add(chest);
     chest.Opener = -1;
     this.availablekeys = this.availablekeys.Add(chest.Keys);
 }
コード例 #6
0
ファイル: TestCase.cs プロジェクト: UIILabsDev/CodeJam
 public TestCase(int[] keys, Chest[] chests)
 {
     this.keys = keys;
     this.chests = chests;
 }
コード例 #7
0
ファイル: 19.cs プロジェクト: qifanyyy/CLCDSA
        public static List <Problem> ParseInput(string[] lines)
        {
            int caseCount = 0;

            List <Problem> problems      = new List <Problem>();
            Problem        problem       = new Problem();
            PARSE_STATE    state         = PARSE_STATE.P_BEGIN;
            int            startKeyCount = 0;
            int            chestCount    = 0;
            int            chestNumber   = 1;

            for (int index = 0; index < lines.Length; index++)
            {
                string line = lines[index];

                if (index == 0)
                {
                    if (!Int32.TryParse(line, out caseCount))
                    {
                        Console.WriteLine("Invalid line {0}:{1}", index, line);
                        break;
                    }
                }
                else if (state == PARSE_STATE.P_BEGIN)
                {
                    string[] items = line.Split(' ');
                    startKeyCount = int.Parse(items[0]);
                    chestCount    = int.Parse(items[1]);
                    state         = PARSE_STATE.P_READ_START;
                }
                else if (state == PARSE_STATE.P_READ_START)
                {
                    string[] items = line.Split(' ');
                    foreach (var item in items)
                    {
                        int key = int.Parse(item);
                        if (problem.KeyStart.ContainsKey(key))
                        {
                            ++problem.KeyStart[key];
                        }
                        else
                        {
                            problem.KeyStart[key] = 1;
                        }
                    }
                    state = PARSE_STATE.P_READ_CHEST;
                }
                else if (state == PARSE_STATE.P_READ_CHEST)
                {
                    Chest chest = new Chest();
                    chest.ChestNumber = chestNumber;
                    ++chestNumber;
                    string[] items = line.Split(' ');
                    for (int i = 0; i < items.Length; i++)
                    {
                        int key = int.Parse(items[i]);

                        if (i == 0)
                        {
                            chest.KeysToOpen = key;
                        }
                        else if (i > 1)
                        {
                            if (chest.KeysInside.ContainsKey(key))
                            {
                                ++chest.KeysInside[key];
                            }
                            else
                            {
                                chest.KeysInside[key] = 1;
                            }
                        }
                    }

                    problem.Chests.Add(chest.ChestNumber, chest);

                    if (problem.Chests.Count == chestCount)
                    {
                        problems.Add(problem);
                        problem       = new Problem();
                        state         = PARSE_STATE.P_BEGIN;
                        startKeyCount = 0;
                        chestCount    = 0;
                        chestNumber   = 1;
                    }
                }
            }

            if (problems.Count != caseCount)
            {
                Console.WriteLine("Invalid case count");
            }

            return(problems);
        }
コード例 #8
0
ファイル: 19.cs プロジェクト: qifanyyy/CLCDSA
        private static void Revert(Dictionary <int, int> availableKeys, List <int> openSequence, Chest chest, Dictionary <int, int> retrievedKey)
        {
            openSequence.RemoveAt(openSequence.Count - 1);
            if (availableKeys.ContainsKey(chest.KeysToOpen))
            {
                ++availableKeys[chest.KeysToOpen];
            }
            else
            {
                availableKeys[chest.KeysToOpen] = 1;
            }

            foreach (var item in retrievedKey)
            {
                availableKeys[item.Key] -= item.Value;
                if (availableKeys[item.Key] == 0)
                {
                    availableKeys.Remove(item.Key);
                }
            }
        }