private static void LongArrayTest()
{
Console.WriteLine("################################");
Console.WriteLine("LONG Array");
Console.WriteLine("################################");
long[,,] dataArray = null;
List <double> searchTimes = new List <double>();
_watch.Restart();
long worldSize = _xSize * _ySize * _zSize;
try
{
dataArray = new long[_xSize, _ySize, _zSize];
}
catch (Exception ex)
{
Console.WriteLine($"Failed to create array, size would have been {_xSize * _ySize * _zSize} MB");
Console.ReadLine();
}
if (dataArray != null)
{
Console.WriteLine($"Instantiating array with {worldSize.ToString("#,####")} cells took {_watch.Elapsed.TotalMilliseconds} ms");
Random rnd = new Random();
_watch.Restart();
for (int x = 0; x < _xSize; x++)
{
for (int y = 0; y < _ySize; y++)
{
for (int z = 0; z < _zSize; z++)
{
dataArray[x, y, z] = (short)rnd.Next(0, short.MaxValue);
}
}
}
Console.WriteLine($"Filling array with random values took {_watch.Elapsed.TotalMilliseconds} ms");
for (int i = 0; i < 10000; i++)
{
int rndX = rnd.Next(0, _xSize);
int rndY = rnd.Next(0, _ySize);
int rndZ = rnd.Next(0, _zSize);
_watch.Restart();
long cellValue = dataArray[rndX, rndY, rndZ];
searchTimes.Add(_watch.Elapsed.TotalMilliseconds);
}
Console.WriteLine($"Searching array took {searchTimes.Average().ToString("#,###0.0000000000")} ms on average");
Console.WriteLine($"Array Size {GetArraySize_Long(dataArray.Length)}MB");
}
Console.WriteLine("################################");
Console.WriteLine("LONG Array End");
Console.WriteLine("################################");
}
public static void Main()
{
Search s = new Search();
string[] str = Console.ReadLine().Split(' ');
int h = int.Parse(str[0]);
int w = int.Parse(str[1]);
long[,] c = new long[10, 10];
for (int i = 0; i < 10; i++)
{
str = Console.ReadLine().Split(' ');
for (int j = 0; j < 10; j++)
{
c[i, j] = long.Parse(str[j]);
}
}
long[,,] b = s.GetMin(c);
long sum = 0;
for (int i = 0; i < h; i++)
{
str = Console.ReadLine().Split(' ');
for (int j = 0; j < w; j++)
{
if (int.Parse(str[j]) != -1)
{
sum += b[8, int.Parse(str[j]), 1];
}
}
}
Console.WriteLine(sum);
}
/// <summary>
/// Render an ascii map of stored data rooms around a specific radius
/// </summary>
/// <param name="room">the room to render the radius around</param>
/// <param name="radius">the radius around the room to render</param>
/// <param name="forAdmin">include edit links for paths and rooms?</param>
/// <param name="withPathways">include paths at all?</param>
/// <returns>a single string that is an ascii map</returns>
public static string RenderRadiusMap(IRoomTemplate room, int radius, bool visibleOnly = false, bool forAdmin = true, bool withPathways = true, ILocaleTemplate locale = null, MapRenderMode renderMode = MapRenderMode.Normal)
{
StringBuilder asciiMap = new StringBuilder();
//Why?
if (room == null)
{
//Don't show "add room" to non admins, if we're not requesting this for a locale and if the locale has actual rooms
if (!forAdmin || locale == null || locale.Rooms().Count() > 0)
{
return(string.Empty);
}
return(string.Format("<a href='#' class='addData pathway AdminAddInitialRoom' localeId='{0}' title='New Room'>Add Initial Room</a>", locale.Id));
}
//1. Get world map
ILocaleTemplate ourLocale = room.ParentLocation;
//2. Get slice of room from world map
long[,,] map = Cartographer.TakeSliceOfMap(new Tuple <int, int>(Math.Max(room.Coordinates.X - radius, 0), room.Coordinates.X + radius)
, new Tuple <int, int>(Math.Max(room.Coordinates.Y - radius, 0), room.Coordinates.Y + radius)
, new Tuple <int, int>(Math.Max(room.Coordinates.Z - 1, 0), room.Coordinates.Z + 1)
, ourLocale.Interior.CoordinatePlane, true);
//3. Flatten the map
long[,] flattenedMap = Cartographer.GetSinglePlane(map, room.Coordinates.Z);
//4. Render slice of room
return(RenderMap(flattenedMap, visibleOnly, forAdmin, withPathways, room, renderMode));
}
private static void RunIteration(long[,,] times, int n, int sizeIdx, int iteration, int workloadSize)
{
var watch = new Stopwatch();
var familiesModel = FamiliesGenerator.GenerateFamilies(n);
var startRule = families2Persons.SynchronizationRule <Families2Persons.Model2ModelMainRule>();
var inputBatchModelContainer = new InputModelContainer(CopyFamilyModel(familiesModel));
var outputBatchModelContainer = new OutputModelContainer(new Model());
watch.Start();
families2Persons.Synchronize(startRule, ref inputBatchModelContainer, ref outputBatchModelContainer, SynchronizationDirection.LeftToRight, ChangePropagationMode.None);
watch.Stop();
times[sizeIdx, iteration, 0] = watch.Elapsed.Ticks * 100;
var inputIncModelContainer = new InputModelContainer(CopyFamilyModel(familiesModel));
var outputIncModelContainer = new OutputModelContainer(new Model());
watch.Restart();
families2Persons.Synchronize(startRule, ref inputIncModelContainer, ref outputIncModelContainer, SynchronizationDirection.LeftToRight, ChangePropagationMode.OneWay);
watch.Stop();
times[sizeIdx, iteration, 1] = watch.Elapsed.Ticks * 100;
var workload = FamiliesGenerator.GenerateChangeWorkload(familiesModel, workloadSize);
PlayBatchNet(times, sizeIdx, iteration, startRule, watch, ref inputBatchModelContainer, ref outputBatchModelContainer, workload);
PlayIncremental(times, sizeIdx, iteration, watch, inputIncModelContainer, workload);
PlayChangesOnly(times, sizeIdx, iteration, watch, CopyFamilyModel(familiesModel), workload);
var inputModelContainer = new InputModelContainer(CopyFamilyModel(familiesModel));
var outputModelContainer = new OutputModelContainer(new Model());
CreateModelsForAtlTransformation(n, iteration, workload, startRule, inputModelContainer, outputModelContainer);
}
private static void FillRoomDimensions(long[,,] coordinatePlane)
{
if (coordinatePlane == null)
{
return;
}
int x, y, z;
for (x = 0; x <= coordinatePlane.GetUpperBound(0); x++)
{
for (y = 0; y <= coordinatePlane.GetUpperBound(1); y++)
{
for (z = 0; z <= coordinatePlane.GetUpperBound(2); z++)
{
if (coordinatePlane[x, y, z] < 0)
{
continue;
}
IRoomTemplate room = TemplateCache.Get <IRoomTemplate>(coordinatePlane[x, y, z]);
if (room == null)
{
continue;
}
room.Coordinates = new Coordinate(x, y, z);
}
}
}
}
private static long[,,] ShrinkMap(long[,,] fullMap, int xLowest, int yLowest, int zLowest, Tuple <int, int> xBounds, Tuple <int, int> yBounds, Tuple <int, int> zBounds)
{
//Maps were the same size
if (xLowest <= 0 && yLowest <= 0 && zLowest <= 0)
{
return(fullMap);
}
long[,,] shrunkMap = new long[fullMap.GetUpperBound(0) + 1 - xLowest, fullMap.GetUpperBound(1) + 1 - yLowest, fullMap.GetUpperBound(2) + 1 - zLowest];
shrunkMap.Populate(-1);
int x, y, z;
for (x = 0; x <= shrunkMap.GetUpperBound(0); x++)
{
if (x <= xBounds.Item2 && x >= xBounds.Item1)
{
for (y = 0; y <= shrunkMap.GetUpperBound(1); y++)
{
if (y <= yBounds.Item2 && y >= yBounds.Item1)
{
for (z = 0; z <= shrunkMap.GetUpperBound(2); z++)
{
shrunkMap[x, y, z] = fullMap[x + xLowest, y + yLowest, z + zLowest];
}
}
}
}
}
return(shrunkMap);
}
/// <summary>
/// Splits the cube in a given color direction at its minimum.
/// </summary>
private static long Bottom(WuColorCube cube, int direction, long[,,] moment)
{
switch (direction)
{
case RED:
return(-moment[cube.RedMinimum, cube.GreenMaximum, cube.BlueMaximum] +
moment[cube.RedMinimum, cube.GreenMaximum, cube.BlueMinimum] +
moment[cube.RedMinimum, cube.GreenMinimum, cube.BlueMaximum] -
moment[cube.RedMinimum, cube.GreenMinimum, cube.BlueMinimum]);
case GREEN:
return(-moment[cube.RedMaximum, cube.GreenMinimum, cube.BlueMaximum] +
moment[cube.RedMaximum, cube.GreenMinimum, cube.BlueMinimum] +
moment[cube.RedMinimum, cube.GreenMinimum, cube.BlueMaximum] -
moment[cube.RedMinimum, cube.GreenMinimum, cube.BlueMinimum]);
case BLUE:
return(-moment[cube.RedMaximum, cube.GreenMaximum, cube.BlueMinimum] +
moment[cube.RedMaximum, cube.GreenMinimum, cube.BlueMinimum] +
moment[cube.RedMinimum, cube.GreenMaximum, cube.BlueMinimum] -
moment[cube.RedMinimum, cube.GreenMinimum, cube.BlueMinimum]);
default:
return(0);
}
}
private static void PlayIncremental(long[,,] times, int n, int sizeIdx, int iteration, Stopwatch watch, InputModelContainer inputModelContainer, OutputModelContainer outputModelContainer, List <MakeWorkloadAction> workload)
{
var outputRepository = new ModelRepository();
Directory.CreateDirectory("makeOutputModelsIncSync");
Directory.CreateDirectory("makeOutputModelsIncSync\\" + n);
Directory.CreateDirectory("makeOutputModelsIncSync\\" + n + "\\" + iteration);
Make2Ant.InputModelContainer = inputModelContainer;
Make2Ant.OutputModelContainer = outputModelContainer;
watch.Restart();
for (int index = 0; index < workload.Count; index++)
{
var item = workload[index];
item.Perform(inputModelContainer.IN);
var tempRepo = new ModelRepository();
tempRepo.Resolve("makeInputModelsSync\\" + n + "\\" + iteration + "\\" + "inputModel" + index + ".xmi");
outputRepository.Save(outputModelContainer.OUT, "makeOutputModelsIncSync\\" + n + "\\" + iteration + "\\" + "outputModel" + index + ".xmi");
}
watch.Stop();
Directory.Delete("makeOutputModelsIncSync", true);
times[sizeIdx, iteration, 3] = watch.Elapsed.Ticks * 100;
}
private static void PlayBatchNet(long[,,] times, int n, int sizeIdx, int iteration, Make2Ant.Model2ModelMainRule startRule, Stopwatch watch, ref InputModelContainer inputModelContainer, ref OutputModelContainer outputModelContainer, List <MakeWorkloadAction> workload)
{
var outputRepository = new ModelRepository();
Directory.CreateDirectory("makeOutputModelsBatchSync");
Directory.CreateDirectory("makeOutputModelsBatchSync\\" + n);
Directory.CreateDirectory("makeOutputModelsBatchSync\\" + n + "\\" + iteration);
Make2Ant.InputModelContainer = inputModelContainer;
Make2Ant.OutputModelContainer = outputModelContainer;
watch.Restart();
for (int index = 0; index < workload.Count; index++)
{
var item = workload[index];
item.Perform(inputModelContainer.IN);
outputModelContainer = new OutputModelContainer(new Model());
RerunBatchSynchronization(startRule, ref inputModelContainer, ref outputModelContainer);
var tempRepo = new ModelRepository();
tempRepo.Resolve("makeInputModelsSync\\" + n + "\\" + iteration + "\\" + "outputModel" + index + ".xmi");
outputRepository.Save(outputModelContainer.OUT, "makeOutputModelsBatchSync\\" + n + "\\" + iteration + "\\" + "outputModel" + index + ".xmi");
}
watch.Stop();
Directory.Delete("makeOutputModelsBatchSync", true);
times[sizeIdx, iteration, 2] = watch.Elapsed.Ticks * 100;
}
/// <summary>
/// Splits the cube in given position, and color direction.
/// </summary>
private static long Top(WuColorCube cube, int direction, int position, long[,,] moment)
{
switch (direction)
{
case Red:
return(moment[position, cube.GreenMaximum, cube.BlueMaximum] -
moment[position, cube.GreenMaximum, cube.BlueMinimum] -
moment[position, cube.GreenMinimum, cube.BlueMaximum] +
moment[position, cube.GreenMinimum, cube.BlueMinimum]);
case Green:
return(moment[cube.RedMaximum, position, cube.BlueMaximum] -
moment[cube.RedMaximum, position, cube.BlueMinimum] -
moment[cube.RedMinimum, position, cube.BlueMaximum] +
moment[cube.RedMinimum, position, cube.BlueMinimum]);
case Blue:
return(moment[cube.RedMaximum, cube.GreenMaximum, position] -
moment[cube.RedMaximum, cube.GreenMinimum, position] -
moment[cube.RedMinimum, cube.GreenMaximum, position] +
moment[cube.RedMinimum, cube.GreenMinimum, position]);
default:
return(0);
}
}
void Solve()
{
io.i(out N, out A);
io.ini(out x, N);
dp = new long[N + 1, N + 1, N * 50 + 1];
dp.Set(-1);
io.o(f(0, 0, 0));
}
/// <summary>
/// Shrinks a map matrix to its exact needed coordinate bounds
/// </summary>
/// <param name="map"></param>
/// <returns></returns>
public static long[,,] ShrinkMap(long[,,] map)
{
//We take a "full slice" of the map to shrink it
return(TakeSliceOfMap(new Tuple <int, int>(map.GetLowerBound(0), map.GetUpperBound(0))
, new Tuple <int, int>(map.GetLowerBound(1), map.GetUpperBound(1))
, new Tuple <int, int>(map.GetLowerBound(2), map.GetUpperBound(2))
, map, true));
}
private RespuestaGeneral ResolverOperacionesMatriz(long[,,] matriz, ArregloCubo cubo, RespuestaGeneral respuestaGeneral)
{
if (!respuestaGeneral.EstadoOperacion)
{
return(respuestaGeneral);
}
return(ResolverOperaciones(cubo, matriz));
}
public RespuestaGeneral EjecutarUpdate(OperacionCubo operacion, long[,,] matriz)
{
respuestaGeneral = validacionDatos.ValidarOperacionUpdate(operacion.InformacionOperacion, ref respuestaGeneral);
if (respuestaGeneral.EstadoOperacion)
{
ActualizarValor(operacion.InformacionOperacion, matriz);
}
return(respuestaGeneral);
}
public RespuestaGeneral ProcesarOperacionUpdate(OperacionCubo operacion, long[,,] matriz, ref RespuestaGeneral respuestaGeneral)
{
respuestaGeneral = ValidarOperacionUpdate(operacion.InformacionOperacion, ref respuestaGeneral);
if (respuestaGeneral.Estado)
{
ActualizarValor(operacion.InformacionOperacion, matriz);
}
return(respuestaGeneral);
}
public RespuestaGeneral ProcesarOperacionQuery(OperacionCubo operacion, long[,,] matriz, ref RespuestaGeneral respuestaGeneral)
{
respuestaGeneral = ValidarOperacionQuery(operacion.InformacionOperacion, ref respuestaGeneral);
if (!respuestaGeneral.Estado)
{
return(respuestaGeneral);
}
return(SumarValor(operacion.InformacionOperacion, matriz, ref respuestaGeneral));
}
private void ActualizarValor(long[] infoOperacion, long[,,] matriz)
{
long x = infoOperacion[0] - 1;
long y = infoOperacion[1] - 1;
long z = infoOperacion[2] - 1;
long valorActualizacion = infoOperacion[3];
matriz[x, y, z] = valorActualizacion;
}
static void Main(string[] args)
{
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
var reader = new StreamReader("b.txt");
var writer = new StreamWriter("b_out.txt");
dp = new long[16, 2000, 16];
price = new long[16, 2000];
left = new long[2000];
var testNumber = long.Parse(reader.ReadLine());
for (long test = 1; test <= testNumber; ++test)
{
var p = long.Parse(reader.ReadLine());
for (int i = 0; i < 16; ++i)
{
for (int j = 0; j < 2000; ++j)
{
for (int l = 0; l < 16; ++l)
{
dp[i, j, l] = -1;
}
}
}
long count = 1;
for (int i = 0; i < p; ++i)
{
count *= 2;
}
string[] input = reader.ReadLine().Split(' ');
for (int i = 0; i < count; ++i)
{
left[i] = p - long.Parse(input[i]);
}
for (int i = 1; i <= p; ++i)
{
count /= 2;
input = reader.ReadLine().Split(' ');
for (int j = 1; j <= count; ++j)
{
price[i, j] = long.Parse(input[j - 1]);
}
}
long result = Memo(p, 1, 0);
writer.WriteLine("Case #{0}: {1}", test, result);
}
reader.Close();
writer.Close();
}
public Solution(int dimensions)
{
if (dimensions == 0)
{
return;
}
this.dimensions = dimensions;
tree = new long[dimensions + 1, dimensions + 1, dimensions + 1];
nums = new long[dimensions, dimensions, dimensions];
}
public PopulationGrowth(DateTime StartDate, DateTime EndDate)
{
startDate = StartDate;
endDate = EndDate;
StartYear = startDate.Year;
EndYear = endDate.Year;
size = EndYear - StartYear;
sizeAge = 140;
Data = new long[2, size + 1, sizeAge];
}
private String recursiveReportPath(Point startPoint, long[,,] minPathArray)
{
Point previousPoint = new Point((int)minPathArray[startPoint.X, startPoint.Y, 2], (int)minPathArray[startPoint.X, startPoint.Y, 3]);
if (startPoint.X == 0)
{
return("" + minPathArray[startPoint.X, startPoint.Y, 0]);
}
return(recursiveReportPath(previousPoint, minPathArray) + " -> " + minPathArray[startPoint.X, startPoint.Y, 0]);
}
private static bool isInMatrix(long[,,] matrix, long dimension)
{
bool result = dimension >= 0 &&
dimension <= matrix.GetLength(0) &&
dimension <= matrix.GetLength(1) &&
dimension <= matrix.GetLength(2) &&
dimension >= 0;
return(result);
}
public RespuestaGeneral EjecutarQuery(OperacionCubo operacion, long[,,] matriz)
{
respuestaGeneral = validacionDatos.ValidarOperacionQuery(operacion.InformacionOperacion, ref respuestaGeneral);
if (!respuestaGeneral.EstadoOperacion)
{
return(respuestaGeneral);
}
AcumularValores(operacion.InformacionOperacion, matriz);
return(respuestaGeneral);
}
private long recursiveMinSumDown(Point distanceTo, long[,,] minPathMatrix, long[,] matrix) //this will keep looking further down and to the left, deciding whether down or left is better for each
{
long leftSum = minPathMatrix[distanceTo.X - 1, distanceTo.Y, 1]; //left sum is always previously calculated, so we just need to find out what it is
long downSum = long.MaxValue;
if (isValid(new Point(distanceTo.X, distanceTo.Y - 1), matrix)) //if moving down isn't valid, then it will remain at long.MaxValue
{
downSum = recursiveMinSumDown(new Point(distanceTo.X, distanceTo.Y - 1), minPathMatrix, matrix); //recursive call
}
return(minPathMatrix[distanceTo.X, distanceTo.Y, 0] + ((leftSum < downSum) ? leftSum : downSum)); //return itself + the sum of the path to get to itself
}
public static void Print(long[,,] k){
for(int i=0;i<k.GetLength(0);i++){
for(int j=0;j<k.GetLength(1);j++){
for(int l=0;l<k.GetLength(2);l++){
Console.Write(k[i,j,l]+" ");
}
Console.WriteLine();
}
Console.WriteLine();
}
}
/// <summary>
/// Computes the volume of the cube in a specific moment.
/// </summary>
private static long Volume(WuColorCube cube, long[,,] moment)
{
return(moment[cube.RedMaximum, cube.GreenMaximum, cube.BlueMaximum] -
moment[cube.RedMaximum, cube.GreenMaximum, cube.BlueMinimum] -
moment[cube.RedMaximum, cube.GreenMinimum, cube.BlueMaximum] +
moment[cube.RedMaximum, cube.GreenMinimum, cube.BlueMinimum] -
moment[cube.RedMinimum, cube.GreenMaximum, cube.BlueMaximum] +
moment[cube.RedMinimum, cube.GreenMaximum, cube.BlueMinimum] +
moment[cube.RedMinimum, cube.GreenMinimum, cube.BlueMaximum] -
moment[cube.RedMinimum, cube.GreenMinimum, cube.BlueMinimum]);
}
private static void PlayChangesOnly(long[,,] times, int sizeIdx, int iteration, Stopwatch watch, Model inputModel, List <FamilyWorkloadAction> workload)
{
watch.Restart();
foreach (var item in workload)
{
item.Perform(inputModel);
}
watch.Stop();
times[sizeIdx, iteration, 4] = watch.Elapsed.Ticks * 100;
}
private static void PlayIncremental(long[,,] times, int sizeIdx, int iteration, Stopwatch watch, InputModelContainer inputModelContainer, List <FamilyWorkloadAction> workload)
{
watch.Restart();
foreach (var item in workload)
{
item.Perform(inputModelContainer.IN);
}
watch.Stop();
times[sizeIdx, iteration, 3] = watch.Elapsed.Ticks * 100;
}
public long[,] NoCalls; // 2D array stores knownCN and REF ploidy for bases where there are no calls
public BaseCounter(int maxCn, int minSize, int maxSize, bool hasRoi = false)
{
MinSize = minSize;
MaxSize = maxSize;
BaseCount = new long[maxCn + 1, maxCn + 1, 3];
NoCalls = new long[maxCn + 1, 3];
if (hasRoi)
{
RoiBaseCount = new long[maxCn + 1, maxCn + 1, 3];
}
}
private static void PlayBatchNet(long[,,] times, int sizeIdx, int iteration, Families2Persons.Model2ModelMainRule startRule, Stopwatch watch, ref InputModelContainer inputModelContainer, ref OutputModelContainer outputModelContainer, List <FamilyWorkloadAction> workload)
{
watch.Restart();
foreach (var item in workload)
{
item.Perform(inputModelContainer.IN);
RerunBatchSynchronization(startRule, ref inputModelContainer, ref outputModelContainer);
}
watch.Stop();
times[sizeIdx, iteration, 2] = watch.Elapsed.Ticks * 100;
}
public void Close()
{
UserData = null;
C2Count = null;
if (m_device != null)
m_device.Close();
m_device = null;
_toc = null;
_toc2 = null;
gapsDetected = false;
readCommandFound = false;
_currentStart = -1;
_currentEnd = -1;
}
