public override void Solve()
{
var pparser = new Pparser(FpatIn);
var x = pparser.Fetch <List <int> >();
var c = pparser.Fetch <List <int> >();
var rgA = pparser.Fetch <int[]>();
var rgB = pparser.Fetch <int[]>();
var fAWins = FWins(x, rgA);
var fBWins = FWins(x, rgB);
var i = 7;
for (; !fAWins && !fBWins; i++)
{
x.Add((x[7] * c[0] + x[6] * c[1] + x[5] * c[2] + x[4] * c[3] + x[3] * c[4] + x[2] * c[5] + x[1] * c[6] + x[0] * c[7]) % 1000);
x.RemoveAt(0);
fAWins = FWins(x, rgA);
fBWins = FWins(x, rgB);
}
using (Output)
{
Solwrt.WriteLine(fAWins ? "A wins at {0}." : "B wins at {0}.", i);
}
}
public override void Solve()
{
var pparser = new Pparser(FpatIn);
int cletter, ccol, crow;
pparser.Fetch(out cletter, out ccol, out crow);
var rgletter = new Letter[cletter];
for (int i = 0; i < cletter; i++)
{
rgletter[i] =
new Letter(pparser.Fetch <string>(), pparser.FetchN <string>(crow).ToArray());
}
var bmpSrc = (Bitmap)Image.FromFile(FpatIn.Replace(".in", ".png"));
var mp = ReadLetters(bmpSrc, rgletter);
using (Output)
foreach (var letter in rgletter)
{
Solwrt.WriteLine(letter.Ch + " " + mp[letter]);
}
}
public override void Solve()
{
var pparser = new Pparser(FpatIn);
int cactor, cfilm;
pparser.Fetch(out cactor, out cfilm);
var rgprice = pparser.FetchN <int>(cactor).ToArray();
var mplayed = new bool[cactor, cactor];
for (int ifilm = 0; ifilm < cfilm; ifilm++)
{
var rgactor = pparser.Fetch <int[]>().Skip(1).ToArray();
for (int i = 0; i < rgactor.Length; i++)
{
for (int j = 0; j < rgactor.Length; j++)
{
if (i == j)
{
continue;
}
//1 based
mplayed[rgactor[i] - 1, rgactor[j] - 1] = true;
}
}
}
int priceMin = int.MaxValue;
for (int iactor = 0; iactor < cactor; iactor++)
{
for (int jactor = 0; jactor < cactor; jactor++)
{
if (iactor == jactor || mplayed[iactor, jactor])
{
continue;
}
var price = rgprice[iactor] + rgprice[jactor];
if (price < priceMin)
{
priceMin = price;
}
}
}
using (Output)
{
if (priceMin == int.MaxValue)
{
Solwrt.WriteLine("No solution.");
}
else
{
Solwrt.WriteLine(priceMin);
}
}
}
public override void Solve()
{
var pparser = new Pparser(FpatIn);
int ccity, cwizard;
pparser.Fetch(out ccity, out cwizard);
var rgcity = pparser.FetchN <Nod>(ccity);
var rgwizard = pparser.FetchN <Nod>(cwizard);
var graph = new CustomGraph();
var mpnodByinod = new Dictionary <long, Nod>();
foreach (var wizard in rgwizard)
{
wizard.kind = Kind.Wizard;
wizard.node = graph.AddNode();
mpnodByinod[wizard.node.Id] = wizard;
}
foreach (var city in rgcity)
{
city.kind = Kind.City;
city.node = graph.AddNode();
mpnodByinod[city.node.Id] = city;
}
foreach (var wizard in rgwizard)
{
foreach (var city in rgcity)
{
if (Dist(wizard, city) <= 50)
{
graph.AddArc(wizard.node, city.node, Directedness.Directed);
}
}
}
var mm = new MaximumMatching(graph, node => mpnodByinod[node.Id].kind == Kind.Wizard);
mm.Run();
using (Output)
{
Solwrt.WriteLine(mm.Matching.ArcCount());
}
}
public override void Solve()
{
var pparser = new Pparser(FpatIn);
var l = pparser.Fetch <int>();
var mp = new Dictionary <int, SortedDictionary <string, string> >();
Foo(l, mp);
using (Output)
{
var rgst = Enst(mp, l).ToList();
rgst.Sort(StringComparer.Ordinal);
foreach (var st in rgst)
{
// Console.WriteLine(st);
Solwrt.WriteLine(st);
}
}
}
public override void Solve()
{
var pparser = new Pparser(FpatIn);
rgx = pparser.Fetch <int[]>();
rgc = pparser.Fetch <int[]>();
rgGoalA = pparser.Fetch <int[]>();
rgGoalB = pparser.Fetch <int[]>();
time = 7;
Winner winner = Winner.Nil;
while (winner == Winner.Nil)
{
winner = Step();
}
string result = winner.ToString() + " wins at " + time.ToString() + ".";
using (Output)
Solwrt.WriteLine(result);
}
public override void Solve()
{
var pparser = new Pparser(FpatIn);
int cknight, cconstraint;
pparser.Fetch(out cknight, out cconstraint);
var knightLim = knightFirst + cknight;
var mprgknightNeedsByknight = new Dictionary <char, List <char> >();
var mprgknightHatesByknight = new Dictionary <char, List <char> >();
for (var knight = knightFirst; knight < knightLim; knight++)
{
mprgknightHatesByknight[knight] = new List <char>();
mprgknightNeedsByknight[knight] = new List <char>();
}
for (var i = 0; i < cconstraint; i++)
{
var rgst = pparser.StLineNext().Split(' ');
char knight = rgst[0][0];
var rgknight = rgst[1] == "needs" ? mprgknightNeedsByknight[knight] : mprgknightHatesByknight[knight];
for (int l = 2; l < rgst.Length; l += 2)
{
rgknight.Add(rgst[l][0]);
}
}
var rgknightNotSeen = new List <char>();
for (var knight = knightFirst; knight < knightLim; knight++)
{
rgknightNotSeen.Add(knight);
}
using (Output)
{
foreach (var knights in Enknights(rgknightNotSeen, null, null, mprgknightNeedsByknight, mprgknightHatesByknight))
{
if (!FOk(knights[cknight - 1], knights[0], knights[1], mprgknightNeedsByknight, mprgknightHatesByknight))
{
continue;
}
if (!FOk(knights[cknight - 2], knights[cknight - 1], knights[0], mprgknightNeedsByknight, mprgknightHatesByknight))
{
continue;
}
for (int i = 0; i < knights.Length; i++)
{
if (!FOk(knights[(i - 1 + knights.Length) % knights.Length], knights[i], knights[(i + 1 + knights.Length) % knights.Length],
mprgknightNeedsByknight, mprgknightHatesByknight))
{
throw new Exception("coki");
}
}
Solwrt.WriteLine(knights);
}
}
}
public override void Solve()
{
int ccol, crow, cstep;
var pparser = new Pparser(FpatIn);
pparser.Fetch(out crow, out ccol, out cstep);
var field = new Kcell[crow, ccol];
for (int irow = 0; irow < crow; irow++)
{
var stLine = pparser.StLineNext();
for (int icol = 0; icol < ccol; icol++)
{
field[irow, icol] = KcellFromCh(stLine[icol]);
}
}
var cgrassMin = CCell(field, Kcell.Grass);
var istepGrassMin = 0;
var fieldGrassMin = field;
var cgrassMax = CCell(field, Kcell.Grass);
var istepGrassMax = 0;
var fieldGrassMax = field;
var crabbitMin = CCell(field, Kcell.Rabbit);
var istepRabbitMin = 0;
var fieldRabbitMin = field;
var crabbitMax = CCell(field, Kcell.Rabbit);
var istepRabbitMax = 0;
var fieldRabbitMax = field;
var cfoxMin = CCell(field, Kcell.Fox);
var istepFoxMin = 0;
var fieldFoxMin = field;
var cfoxMax = CCell(field, Kcell.Fox);
var istepFoxMax = 0;
var fieldFoxMax = field;
using (var solwrt = new Solwrt(FpatOut, FpatRefout))
{
for (int istep = 0; istep < cstep;)
{
field = Step(istep, field);
istep++;
var cgrass = CCell(field, Kcell.Grass);
var crabbit = CCell(field, Kcell.Rabbit);
var cfox = CCell(field, Kcell.Fox);
if (crabbit > crabbitMax)
{
crabbitMax = crabbit; istepRabbitMax = istep; fieldRabbitMax = field;
}
if (crabbit < crabbitMin)
{
crabbitMin = crabbit; istepRabbitMin = istep; fieldRabbitMin = field;
}
if (cgrass > cgrassMax)
{
cgrassMax = cgrass; istepGrassMax = istep; fieldGrassMax = field;
}
if (cgrass < cgrassMin)
{
cgrassMin = cgrass; istepGrassMin = istep; fieldGrassMin = field;
}
if (cfox > cfoxMax)
{
cfoxMax = cfox; istepFoxMax = istep; fieldFoxMax = field;
}
if (cfox < cfoxMin)
{
cfoxMin = cfox; istepFoxMin = istep; fieldFoxMin = field;
}
solwrt.WriteLine("{0} {1} {2}", cgrass, crabbit, cfox);
}
solwrt.WriteLine("Minimum number of grass: {0} after step {1}.", cgrassMin, istepGrassMin);
solwrt.WriteLine("Maximum number of grass: {0} after step {1}.", cgrassMax, istepGrassMax);
solwrt.WriteLine("Minimum number of rabbits: {0} after step {1}.", crabbitMin, istepRabbitMin);
solwrt.WriteLine("Maximum number of rabbits: {0} after step {1}.", crabbitMax, istepRabbitMax);
solwrt.WriteLine("Minimum number of foxes: {0} after step {1}.", cfoxMin, istepFoxMin);
solwrt.WriteLine("Maximum number of foxes: {0} after step {1}.", cfoxMax, istepFoxMax);
}
SaveField(fieldGrassMin, FpatOut.Replace(".out", "-1.png"));
SaveField(fieldGrassMax, FpatOut.Replace(".out", "-2.png"));
SaveField(fieldRabbitMin, FpatOut.Replace(".out", "-3.png"));
SaveField(fieldRabbitMax, FpatOut.Replace(".out", "-4.png"));
SaveField(fieldFoxMin, FpatOut.Replace(".out", "-5.png"));
SaveField(fieldFoxMax, FpatOut.Replace(".out", "-6.png"));
}
public void WriteLine(object obj)
{
Solwrt.WriteLine(obj);
}