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);
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 void Find(Solwrt solwrt)
{
SolutionFinder finder = new SolutionFinder();
IList solutions = finder.FindSolutions(new KnightSolutionEnumerator(hatesMap, needsMap, KnigtsNumber));
foreach (KnightSolution solution in solutions)
{
solwrt.Write(solution.ToString());
}
}
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()
{
int cpart, cch;
Pparser.Fetch(out cpart, out cch);
var rgst = Pparser.FetchN <string>(cpart).ToArray();
var mpnodeByst = new Dictionary <string, Node>();
foreach (var st in rgst)
{
var stA = st.Substring(0, 5);
var stB = st.Substring(st.Length - 5);
if (!mpnodeByst.ContainsKey(stA))
{
mpnodeByst[stA] = new Node(stA);
}
if (!mpnodeByst.ContainsKey(stB))
{
mpnodeByst[stB] = new Node(stB);
}
var edge = new Edge(st, mpnodeByst[stA], mpnodeByst[stB]);
mpnodeByst[stA].rgedgeOut.Add(edge);
mpnodeByst[stB].rgedgeIn.Add(edge);
}
var rgedge = Euler(new HashSet <Node>(mpnodeByst.Values)).ToArray();
Sanity(rgedge, rgst);
string stResult = "";
stResult = rgedge[0].st;
for (int i = 1; i < rgedge.Length; i++)
{
stResult += rgedge[i].st.Substring(5);
}
using (Output)
{
Solwrt.Write(stResult);
}
}
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 override void Solve()
{
var st = Fetch <string>();
int cch = st.Length / 2;
var rgc = new int[cch];
for (int i = 0; i < cch; i++)
{
rgc[i] = (st[2 * i] - 'A') * 16 + st[2 * i + 1] - 'A';
}
var rgb = new int[cch];
for (int i = 0; i < cch; i++)
{
int k = i + 1;
if (FPrime(k))
{
rgb[i] = (rgc[i] - k + 512) % 256;
}
else
{
rgb[i] = rgc[i];
}
}
var rga = new int[cch];
rga[0] = rgb[0];
for (int i = 1; i < cch; i++)
{
rga[i] = (rgb[i] - rgb[i - 1] + 512) % 256;
}
st = new string(rga.Select(a => (char)a).ToArray());
var rgch = new char[cch];
int s = (int)Math.Sqrt(cch);
{
var rgaPrev = new List <int>();
for (int ip = cch - 1; ip >= 0; ip--)
{
if (rgaPrev.Count > 1)
{
int p = rgaPrev[0];
rgaPrev[0] = rgaPrev[1];
rgaPrev[1] = p;
}
if (rgaPrev.Count > 12)
{
rgaPrev = rgaPrev.Skip(rgaPrev.Count - 12).Concat(rgaPrev.Take(rgaPrev.Count - 12)).ToList();
}
rgaPrev.Insert(0, rga[ip]);
}
rga = rgaPrev.ToArray();
}
{
int i = 0;
int d = 0;
while (i < cch)
{
for (int l = d; l >= 0; l--)
{
int x = d - l;
int y = d - x;
if (x >= s)
{
break;
}
if (x < 0 || x > s - 1 || y < 0 || y > s - 1)
{
continue;
}
rgch[x + y * s] = (char)rga[i++];
}
d++;
}
}
st = new string(rgch);
using (Output)
{
Solwrt.Write("{0}", st);
}
}
public override void Solve()
{
var pparser = new Pparser(FpatIn);
int n, l;
pparser.Fetch(out n, out l);
var rgnode = pparser.FetchN <Node>(n);
rgnode.Add(new Node("X"));
n++;
var solver = Google.OrTools.LinearSolver.Solver.CreateSolver("IntegerProgramming",
"CBC_MIXED_INTEGER_PROGRAMMING");
for (int i = 0; i < n; i++)
{
rgnode[i].varU = solver.MakeIntVar(0, n, "U{0}".StFormat(i));
}
var mpnodeByVarout = new Dictionary <Variable, Node>();
var rgvarx = new List <Variable>();
for (var i = 0; i < n; i++)
{
for (var j = 0; j < n; j++)
{
if (i == j)
{
continue;
}
if (Node.FMatch(rgnode[i], rgnode[j]))
{
var varXij = solver.MakeIntVar(0, 1, "x{0}_{1}".StFormat(i, j));
rgvarx.Add(varXij);
rgnode[i].rgvarOut.Add(varXij);
rgnode[j].rgvarIn.Add(varXij);
mpnodeByVarout[varXij] = rgnode[j];
if (i > 0 && j > 0)
{
solver.Add(rgnode[i].varU - rgnode[j].varU + varXij * n <= n - 1);
}
}
}
}
foreach (var node in rgnode)
{
solver.Add(new SumVarArray(node.rgvarOut.ToArray()) == 1);
solver.Add(new SumVarArray(node.rgvarIn.ToArray()) == 1);
}
solver.Maximize(new SumVarArray(rgvarx.ToArray()));
solver.SetTimeLimit(60 * 1000);
var resultStatus = solver.Solve();
double min, max;
if (resultStatus == Google.OrTools.LinearSolver.Solver.OPTIMAL)
{
min = max = solver.Objective().Value();
var nodeCur = rgnode.Last();
int s = 0;
var rgst = new List <string>();
while (nodeCur != null)
{
Console.WriteLine("{0}\t{1}", ++s, nodeCur.st);
rgst.Add(nodeCur.st);
var varOut = nodeCur.rgvarOut.SingleOrDefault(var => var.SolutionValue() == 1);
if (varOut != null)
{
nodeCur = mpnodeByVarout[varOut];
}
else
{
nodeCur = null;
}
if (nodeCur == rgnode.Last())
{
break;
}
}
rgst = rgst.Skip(1).ToList();
string stResult = "";
stResult = rgst[0];
for (int i = 1; i < rgst.Count; i++)
{
stResult += rgst[i].Substring(5);
}
using (Output)
{
Solwrt.Write(stResult);
}
}
else
{
min = solver.Objective().Value();
max = solver.Objective().BestBound();
}
Console.WriteLine(min);
Console.WriteLine(max);
}
