Tasks Details
hard
Find a path in given matrix, such that the product of all the numbers on the path has the minimal number of trailing zeros.
Task Score
55%
Correctness
100%
Performance
11%
Matrix A, consisting of N rows and N columns of non-negative integers, is given. Rows are numbered from 0 to N−1 (from top to bottom). Columns are numbered from 0 to N−1 (from left to right). We would like to find a path that starts at the upper-left corner (0, 0) and, moving only right and down, finishes at the bottom-right corner (N−1, N−1). Then, all the numbers on this path will be multiplied together.
Find a path such that the product of all the numbers on the path contain the minimal number of trailing zeros. We assume that 0 has 1 trailing zero.
Write a function:
class Solution { public int solution(int[][] A); }
that, given matrix A, returns the minimal number of trailing zeros.
Examples:
1. Given matrix A below:
the function should return 1. The optimal path is: (0,0) → (0,1) → (0,2) → (1,2) → (2,2) → (2,3) → (3,3). The product of numbers 2, 10, 1, 4, 2, 1, 1 is 160, which has one trailing zero. There is no path that yields a product with no trailing zeros.
2. Given matrix A below:
the function should return 2. One of the optimal paths is: (0,0) → (1,0) → (1,1) → (1,2) → (2,2) → (3,2) → (3,3). The product of numbers 10, 1, 1, 1, 10, 1, 1 is 100, which has two trailing zeros. There is no path that yields a product with fewer than two trailing zeros.
3. Given matrix A below:
the function should return 1. One of the optimal paths is: (0,0) → (0,1) → (1,1) → (1,2) → (2,2). The product of numbers 10, 10, 0, 10, 10 is 0, which has one trailing zero. There is no path that yields a product with no trailing zeros.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..500];
- each element of matrix A is an integer within the range [0..1,000,000,000].
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used C#
Time spent on task 48 minutes
Notes
not defined yet
Code: 03:07:31 UTC,
java,
autosave
Code: 03:07:35 UTC,
cs,
autosave
using System;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class Solution {
public int solution(int[][] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
}
}
Code: 03:07:41 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:08:12 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:08:29 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:08:55 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:09:25 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:09:55 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:10:15 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:10:45 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:11:10 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(10000000);
if(1 < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(1);
if(1 < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:11:39 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(10000000);
if(10000000 < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(10000000);
if(10000000 < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:12:09 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:12:40 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:12:54 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:12:58 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Analysis
Compile error
Compilation failed: 1 error(s), 0 warnings Solution.cs(122,32): error CS1519: Unexpected symbol `=' in class, struct, or interface member declaration
Code: 03:13:08 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Analysis
expand all
Example tests
1.
0.028 s
WRONG ANSWER,
got 2 expected 1
1.
0.024 s
WRONG ANSWER,
got 3 expected 2
1.
0.024 s
WRONG ANSWER,
got 5 expected 1
Code: 03:13:24 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.)
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:13:54 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.)
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:14:10 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:14:40 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:14:51 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:15:10 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:15:15 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
got 2 expected 1
1.
0.036 s
WRONG ANSWER,
got 3 expected 2
1.
0.036 s
WRONG ANSWER,
got 5 expected 1
Code: 03:15:47 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:16:13 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private static CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Analysis
expand all
Example tests
1.
0.024 s
WRONG ANSWER,
got 2 expected 1
1.
0.024 s
WRONG ANSWER,
got 3 expected 2
1.
0.024 s
WRONG ANSWER,
got 5 expected 1
Code: 03:17:30 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private static CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<10000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:18:21 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private static CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:18:39 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private static CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:18:52 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private static CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1) return minimum.Distance;
}
return 0;
}
}
Code: 03:19:22 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private static CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero)
return minDistance;
}
}
Code: 03:19:32 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private static CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:19:46 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private static CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest, int maxRow, int maxCol){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:20:08 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private static CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:20:16 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private static CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
existsSomeZero = true;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.024 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0
1.
0.024 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0
1.
0.024 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0
Code: 03:20:48 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
existsSomeZero = true;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:20:51 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
existsSomeZero = true;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0
1.
0.032 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0
Code: 03:21:43 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
existsSomeZero = true;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:21:57 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
existsSomeZero = true;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down");
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:22:12 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
existsSomeZero = true;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down");
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right");
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:22:18 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
existsSomeZero = true;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down");
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right");
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.024 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0
1.
0.024 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0
1.
0.024 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0
Code: 03:23:56 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, 1, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
existsSomeZero = true;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down");
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right");
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:24:06 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
newNodeZero.SetIsNodeZero();
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
existsSomeZero = true;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down");
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right");
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:24:16 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public bool IsNodeZero {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
IsNodeZero = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
existsSomeZero = true;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down");
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right");
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:24:37 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
public void SetIsNodeZero(){
IsNodeZero = true;
}
public void ForceDistance(int distance){
Distance = distance;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
existsSomeZero = true;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down");
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right");
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:24:47 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(node.IsNodeZero){
existsSomeZero = true;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down");
if(!down.Picked){
down.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right");
if(!right.Picked){
right.ForceDistance(BIG_DISTANCE);
if(BIG_DISTANCE < minDistance){
nodeMinDistance = right;
}
}
}
}
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:25:07 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:25:10 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(1000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0
1.
0.028 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0
1.
0.028 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0
Code: 03:25:46 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(1000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:25:56 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:26:16 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
Console.WriteLine("(" + x + "," + y + ")");
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0stdout:
(0,0) (0,0) (0,1) (0,0) (0,1) (0,2) (0,0) (0,1) (0,2) (0,3) (0,0) (0,1) (0,2) (0,3) (1,3) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (1,1) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (1,1) (2,1) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (1,1) (2,1) (3,1) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (1,1) (2,1) (3,1) (1,0) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (1,1) (2,1) (3,1) (1,0) (2,0) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (1,1) (2,1) (3,1) (1,0) (2,0) (3,0)
1.
0.036 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0stdout:
(0,0) (0,0) (0,1) (0,0) (0,1) (0,2) (0,0) (0,1) (0,2) (0,3) (0,0) (0,1) (0,2) (0,3) (1,3) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (1,1) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (1,1) (2,1) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (1,1) (2,1) (3,1) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (1,1) (2,1) (3,1) (1,0) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (1,1) (2,1) (3,1) (1,0) (2,0) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) (1,2) (2,2) (3,2) (1,1) (2,1) (3,1) (1,0) (2,0) (3,0)
1.
0.024 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0stdout:
(0,0) (0,0) (0,1) (0,0) (0,1) (0,2) (0,0) (0,1) (0,2) (1,2) (0,0) (0,1) (0,2) (1,2) (2,2) (0,0) (0,1) (0,2) (1,2) (2,2) (1,1) (0,0) (0,1) (0,2) (1,2) (2,2) (1,1) (2,1) (0,0) (0,1) (0,2) (1,2) (2,2) (1,1) (2,1) (1,0) (0,0) (0,1) (0,2) (1,2) (2,2) (1,1) (2,1) (1,0) (2,0)
Code: 03:26:41 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:27:05 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
WRONG ANSWER,
got 2 expected 1
1.
0.028 s
WRONG ANSWER,
got 3 expected 2
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
Code: 03:27:23 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:27:30 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
Console.WriteLine("(" + x + "," + y + ")");
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
WRONG ANSWER,
got 2 expected 1
stdout:
(0,0) (0,0) (0,1) (0,0) (0,1) (0,2) (0,0) (0,1) (0,2) (0,3) (0,0) (0,1) (0,2) (0,3) (1,3) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3)
1.
0.028 s
WRONG ANSWER,
got 3 expected 2
stdout:
(0,0) (0,0) (0,1) (0,0) (0,1) (0,2) (0,0) (0,1) (0,2) (0,3) (0,0) (0,1) (0,2) (0,3) (1,3) (0,0) (0,1) (0,2) (0,3) (1,3) (2,3)
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
stdout:
(0,0) (0,0) (0,1) (0,0) (0,1) (0,2) (0,0) (0,1) (0,2) (1,2)
Code: 03:30:03 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
Console.WriteLine("(" + x + "," + y + "):");
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:30:12 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
WRONG ANSWER,
got 2 expected 1
stdout:
(0,0): True (0,0): True (0,1): True (0,0): True (0,1): True (0,2): True (0,0): True (0,1): True (0,2): True (0,3): True (0,0): True (0,1): True (0,2): True (0,3): True (1,3): True (0,0): True (0,1): True (0,2): True (0,3): True (1,3): True (2,3): True
1.
0.028 s
WRONG ANSWER,
got 3 expected 2
stdout:
(0,0): True (0,0): True (0,1): True (0,0): True (0,1): True (0,2): True (0,0): True (0,1): True (0,2): True (0,3): True (0,0): True (0,1): True (0,2): True (0,3): True (1,3): True (0,0): True (0,1): True (0,2): True (0,3): True (1,3): True (2,3): True
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
stdout:
(0,0): True (0,0): True (0,1): True (0,0): True (0,1): True (0,2): True (0,0): True (0,1): True (0,2): True (1,2): True
Code: 03:30:49 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:30:52 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0stdout:
(0,0): True
1.
0.028 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0stdout:
(0,0): True
1.
0.028 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0stdout:
(0,0): True
Code: 03:31:07 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:31:08 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
WRONG ANSWER,
got 2 expected 1
stdout:
(0,0): True (0,0): True (0,1): True (0,0): True (0,1): True (0,2): True (0,0): True (0,1): True (0,2): True (0,3): True (0,0): True (0,1): True (0,2): True (0,3): True (1,3): True (0,0): True (0,1): True (0,2): True (0,3): True (1,3): True (2,3): True
1.
0.028 s
WRONG ANSWER,
got 3 expected 2
stdout:
(0,0): True (0,0): True (0,1): True (0,0): True (0,1): True (0,2): True (0,0): True (0,1): True (0,2): True (0,3): True (0,0): True (0,1): True (0,2): True (0,3): True (1,3): True (0,0): True (0,1): True (0,2): True (0,3): True (1,3): True (2,3): True
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
stdout:
(0,0): True (0,0): True (0,1): True (0,0): True (0,1): True (0,2): True (0,0): True (0,1): True (0,2): True (1,2): True
Code: 03:32:24 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:32:39 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:32:47 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
WRONG ANSWER,
got 2 expected 1
stdout:
(0,0): True (0,0): True (0,1): True (0,0): True (0,1): True (0,2): True (0,0): True (0,1): True (0,2): True (0,3): True (0,0): True (0,1): True (0,2): True (0,3): True (1,3): True (0,0): True (0,1): True (0,2): True (0,3): True (1,3): True (2,3): True
1.
0.028 s
WRONG ANSWER,
got 3 expected 2
stdout:
(0,0): True (0,0): True (0,1): True (0,0): True (0,1): True (0,2): True (0,0): True (0,1): True (0,2): True (0,3): True (0,0): True (0,1): True (0,2): True (0,3): True (1,3): True (0,0): True (0,1): True (0,2): True (0,3): True (1,3): True (2,3): True
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
stdout:
(0,0): True (0,0): True (0,1): True (0,0): True (0,1): True (0,2): True (0,0): True (0,1): True (0,2): True (1,2): True
Code: 03:34:30 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
if(down == null) Console.WriteLine("down2");
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
if(right == null) Console.WriteLine("right2");
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:34:50 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:35:18 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private printNode(Node node){
if(node == null) Console.WriteLine("null");
else Console.WriteLine("")
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:35:30 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private printNode(Node node){
if(node == null) Console.WriteLine("null");
else Console.WriteLine("(" + x + "," + y + "")
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:35:54 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private printNode(Node node){
if(node == null) Console.WriteLine("null");
else Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
Compile error
Compilation failed: 1 error(s), 0 warnings Solution.cs(119,13): error CS1520: Class, struct, or interface method must have a return type
Code: 03:36:01 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:36:02 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
WRONG ANSWER,
got 2 expected 1
stdout:
(0,0): True (1,0: 1) (0,1: 1) (0,0): True (1,0: 1) (0,1: 1) (0,1): True (1,1: 2) (0,2: 1) (0,0): True (1,0: 1) (0,1: 1) (0,1): True (1,1: 2) (0,2: 1) (0,2): True (1,2: 1) (0,3: 1) (0,0): True (1,0: 1) (0,1: 1) (0,1): True (1,1: 2) (0,2: 1) (0,2): True (1,2: 1) (0,3: 1) (0,3): True (1,3: 2) (0,0): True (1,0: 1) (0,1: 1) (0,1): True (1,1: 2) (0,2: 1) (0,2): True (1,2: 1) (0,3: 1) (0,3): True (1,3: 2) (1,3): True (2,3: 2) (0,0): True (1,0: 1) (0,1: 1) (0,1): True (1,1: 2) (0,2: 1) (0,2): True (1,2: 1) (0,3: 1) (0,3): True (1,3: 2) (1,3): True (2,3: 2) (2,3): True (3,3: 2)
1.
0.028 s
WRONG ANSWER,
got 3 expected 2
stdout:
(0,0): True (1,0: 1) (0,1: 1) (0,0): True (1,0: 1) (0,1: 1) (0,1): True (1,1: 1) (0,2: 2) (0,0): True (1,0: 1) (0,1: 1) (0,1): True (1,1: 1) (0,2: 2) (0,2): True (1,2: 2) (0,3: 2) (0,0): True (1,0: 1) (0,1: 1) (0,1): True (1,1: 1) (0,2: 2) (0,2): True (1,2: 2) (0,3: 2) (0,3): True (1,3: 3) (0,0): True (1,0: 1) (0,1: 1) (0,1): True (1,1: 1) (0,2: 2) (0,2): True (1,2: 2) (0,3: 2) (0,3): True (1,3: 3) (1,3): True (2,3: 3) (0,0): True (1,0: 1) (0,1: 1) (0,1): True (1,1: 1) (0,2: 2) (0,2): True (1,2: 2) (0,3: 2) (0,3): True (1,3: 3) (1,3): True (2,3: 3) (2,3): True (3,3: 3)
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
stdout:
(0,0): True (1,0: 2) (0,1: 2) (0,0): True (1,0: 2) (0,1: 2) (0,1): True (1,1: 10000000) (0,2: 3) (0,0): True (1,0: 2) (0,1: 2) (0,1): True (1,1: 10000000) (0,2: 3) (0,2): True (1,2: 4) (0,0): True (1,0: 2) (0,1: 2) (0,1): True (1,1: 10000000) (0,2: 3) (0,2): True (1,2: 4) (1,2): True (2,2: 5)
Code: 03:36:31 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:36:34 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
Console.WriteLine("(" + x + "," + y + "): " + node.Picked);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
got 2 expected 1
stdout:
(0,0): True (1,0: 1, False) (0,1: 1, False) (0,0): True (1,0: 1, False) (0,1: 1, True) (0,1): True (1,1: 2, False) (0,2: 1, False) (0,0): True (1,0: 1, False) (0,1: 1, True) (0,1): True (1,1: 2, False) (0,2: 1, True) (0,2): True (1,2: 1, False) (0,3: 1, False) (0,0): True (1,0: 1, False) (0,1: 1, True) (0,1): True (1,1: 2, False) (0,2: 1, True) (0,2): True (1,2: 1, False) (0,3: 1, True) (0,3): True (1,3: 2, False) (0,0): True (1,0: 1, False) (0,1: 1, True) (0,1): True (1,1: 2, False) (0,2: 1, True) (0,2): True (1,2: 1, False) (0,3: 1, True) (0,3): True (1,3: 2, True) (1,3): True (2,3: 2, False) (0,0): True (1,0: 1, False) (0,1: 1, True) (0,1): True (1,1: 2, False) (0,2: 1, True) (0,2): True (1,2: 1, False) (0,3: 1, True) (0,3): True (1,3: 2, True) (1,3): True (2,3: 2, True) (2,3): True (3,3: 2, False)
1.
0.028 s
WRONG ANSWER,
got 3 expected 2
stdout:
(0,0): True (1,0: 1, False) (0,1: 1, False) (0,0): True (1,0: 1, False) (0,1: 1, True) (0,1): True (1,1: 1, False) (0,2: 2, False) (0,0): True (1,0: 1, False) (0,1: 1, True) (0,1): True (1,1: 1, False) (0,2: 2, True) (0,2): True (1,2: 2, False) (0,3: 2, False) (0,0): True (1,0: 1, False) (0,1: 1, True) (0,1): True (1,1: 1, False) (0,2: 2, True) (0,2): True (1,2: 2, False) (0,3: 2, True) (0,3): True (1,3: 3, False) (0,0): True (1,0: 1, False) (0,1: 1, True) (0,1): True (1,1: 1, False) (0,2: 2, True) (0,2): True (1,2: 2, False) (0,3: 2, True) (0,3): True (1,3: 3, True) (1,3): True (2,3: 3, False) (0,0): True (1,0: 1, False) (0,1: 1, True) (0,1): True (1,1: 1, False) (0,2: 2, True) (0,2): True (1,2: 2, False) (0,3: 2, True) (0,3): True (1,3: 3, True) (1,3): True (2,3: 3, True) (2,3): True (3,3: 3, False)
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
stdout:
(0,0): True (1,0: 2, False) (0,1: 2, False) (0,0): True (1,0: 2, False) (0,1: 2, True) (0,1): True (1,1: 10000000, False) (0,2: 3, False) (0,0): True (1,0: 2, False) (0,1: 2, True) (0,1): True (1,1: 10000000, False) (0,2: 3, True) (0,2): True (1,2: 4, False) (0,0): True (1,0: 2, False) (0,1: 2, True) (0,1): True (1,1: 10000000, False) (0,2: 3, True) (0,2): True (1,2: 4, True) (1,2): True (2,2: 5, False)
Code: 03:36:56 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
WRONG ANSWER,
got 2 expected 1
stdout:
(0,0: 0, True) (1,0: 1, False) (0,1: 1, False) (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) (0,2: 1, True) (1,2: 1, False) (0,3: 1, False) (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) (0,2: 1, True) (1,2: 1, False) (0,3: 1, True) (0,3: 1, True) (1,3: 2, False) (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) (0,2: 1, True) (1,2: 1, False) (0,3: 1, True) (0,3: 1, True) (1,3: 2, True) (1,3: 2, True) (2,3: 2, False) (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) (0,2: 1, True) (1,2: 1, False) (0,3: 1, True) (0,3: 1, True) (1,3: 2, True) (1,3: 2, True) (2,3: 2, True) (2,3: 2, True) (3,3: 2, False)
1.
0.028 s
WRONG ANSWER,
got 3 expected 2
stdout:
(0,0: 1, True) (1,0: 1, False) (0,1: 1, False) (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) (0,1: 1, True) (1,1: 1, False) (0,2: 2, False) (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) (0,2: 2, True) (1,2: 2, False) (0,3: 2, False) (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) (0,2: 2, True) (1,2: 2, False) (0,3: 2, True) (0,3: 2, True) (1,3: 3, False) (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) (0,2: 2, True) (1,2: 2, False) (0,3: 2, True) (0,3: 2, True) (1,3: 3, True) (1,3: 3, True) (2,3: 3, False) (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) (0,2: 2, True) (1,2: 2, False) (0,3: 2, True) (0,3: 2, True) (1,3: 3, True) (1,3: 3, True) (2,3: 3, True) (2,3: 3, True) (3,3: 3, False)
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
stdout:
(0,0: 1, True) (1,0: 2, False) (0,1: 2, False) (0,0: 1, True) (1,0: 2, False) (0,1: 2, True) (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) (0,0: 1, True) (1,0: 2, False) (0,1: 2, True) (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) (0,2: 3, True) (1,2: 4, False) (0,0: 1, True) (1,0: 2, False) (0,1: 2, True) (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) (0,2: 3, True) (1,2: 4, True) (1,2: 4, True) (2,2: 5, False)
Code: 03:37:19 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
C
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:37:27 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
WRONG ANSWER,
got 2 expected 1
stdout:
---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, False) ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, False) ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, True) ---- (0,3: 1, True) (1,3: 2, False) ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, True) ---- (0,3: 1, True) (1,3: 2, True) ---- (1,3: 2, True) (2,3: 2, False) ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, True) ---- (0,3: 1, True) (1,3: 2, True) ---- (1,3: 2, True) (2,3: 2, True) ---- (2,3: 2, True) (3,3: 2, False)
1.
0.028 s
WRONG ANSWER,
got 3 expected 2
stdout:
---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, False) ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, False) ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) ---- (0,2: 2, True) (1,2: 2, False) (0,3: 2, False) ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) ---- (0,2: 2, True) (1,2: 2, False) (0,3: 2, True) ---- (0,3: 2, True) (1,3: 3, False) ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) ---- (0,2: 2, True) (1,2: 2, False) (0,3: 2, True) ---- (0,3: 2, True) (1,3: 3, True) ---- (1,3: 3, True) (2,3: 3, False) ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) ---- (0,2: 2, True) (1,2: 2, False) (0,3: 2, True) ---- (0,3: 2, True) (1,3: 3, True) ---- (1,3: 3, True) (2,3: 3, True) ---- (2,3: 3, True) (3,3: 3, False)
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
stdout:
---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, False) ---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, True) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, True) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (0,2: 3, True) (1,2: 4, False) ---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, True) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (0,2: 3, True) (1,2: 4, True) ---- (1,2: 4, True) (2,2: 5, False)
Code: 03:38:58 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
Con
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:39:07 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.036 s
WRONG ANSWER,
got 2 expected 1
stdout:
---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, False) ----end ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ----end ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, False) ----end ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, True) ---- (0,3: 1, True) (1,3: 2, False) ----end ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, True) ---- (0,3: 1, True) (1,3: 2, True) ---- (1,3: 2, True) (2,3: 2, False) ----end ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, True) ---- (0,3: 1, True) (1,3: 2, True) ---- (1,3: 2, True) (2,3: 2, True) ---- (2,3: 2, True) (3,3: 2, False) ----end
1.
0.040 s
WRONG ANSWER,
got 3 expected 2
stdout:
---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, False) ----end ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, False) ----end ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) ---- (0,2: 2, True) (1,2: 2, False) (0,3: 2, False) ----end ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) ---- (0,2: 2, True) (1,2: 2, False) (0,3: 2, True) ---- (0,3: 2, True) (1,3: 3, False) ----end ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) ---- (0,2: 2, True) (1,2: 2, False) (0,3: 2, True) ---- (0,3: 2, True) (1,3: 3, True) ---- (1,3: 3, True) (2,3: 3, False) ----end ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) ---- (0,2: 2, True) (1,2: 2, False) (0,3: 2, True) ---- (0,3: 2, True) (1,3: 3, True) ---- (1,3: 3, True) (2,3: 3, True) ---- (2,3: 3, True) (3,3: 3, False) ----end
1.
0.036 s
WRONG ANSWER,
got 5 expected 1
stdout:
---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, False) ----end ---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, True) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ----end ---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, True) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (0,2: 3, True) (1,2: 4, False) ----end ---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, True) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (0,2: 3, True) (1,2: 4, True) ---- (1,2: 4, True) (2,2: 5, False) ----end
Code: 03:39:53 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
C
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:40:06 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
WRONG ANSWER,
got 2 expected 1
stdout:
---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (0,1: 1, True) ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ----end minimum: (0,2: 1, True) ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, False) ----end minimum: (0,3: 1, True) ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, True) ---- (0,3: 1, True) (1,3: 2, False) ----end minimum: (1,3: 2, True) ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, True) ---- (0,3: 1, True) (1,3: 2, True) ---- (1,3: 2, True) (2,3: 2, False) ----end minimum: (2,3: 2, True) ---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, True) ---- (0,3: 1, True) (1,3: 2, True) ---- (1,3: 2, True) (2,3: 2, True) ---- (2,3: 2, True) (3,3: 2, False) ----end minimum: (3,3: 2, True)
1.
0.028 s
WRONG ANSWER,
got 3 expected 2
stdout:
---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (0,1: 1, True) ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, False) ----end minimum: (0,2: 2, True) ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) ---- (0,2: 2, True) (1,2: 2, False) (0,3: 2, False) ----end minimum: (0,3: 2, True) ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) ---- (0,2: 2, True) (1,2: 2, False) (0,3: 2, True) ---- (0,3: 2, True) (1,3: 3, False) ----end minimum: (1,3: 3, True) ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) ---- (0,2: 2, True) (1,2: 2, False) (0,3: 2, True) ---- (0,3: 2, True) (1,3: 3, True) ---- (1,3: 3, True) (2,3: 3, False) ----end minimum: (2,3: 3, True) ---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, True) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, True) ---- (0,2: 2, True) (1,2: 2, False) (0,3: 2, True) ---- (0,3: 2, True) (1,3: 3, True) ---- (1,3: 3, True) (2,3: 3, True) ---- (2,3: 3, True) (3,3: 3, False) ----end minimum: (3,3: 3, True)
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
stdout:
---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, False) ----end minimum: (0,1: 2, True) ---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, True) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ----end minimum: (0,2: 3, True) ---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, True) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (0,2: 3, True) (1,2: 4, False) ----end minimum: (1,2: 4, True) ---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, True) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (0,2: 3, True) (1,2: 4, True) ---- (1,2: 4, True) (2,2: 5, False) ----end minimum: (2,2: 5, True)
Code: 03:41:10 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:41:21 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = false;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
OK
stdout:
---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ----end minimum: (0,1: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ----end minimum: (2,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ----end minimum: (0,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, False) ----end minimum: (1,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, False) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ----end minimum: (0,3: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ----end minimum: (2,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, True) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ---- (2,2: 1, True) (3,2: 2, False) (2,3: 1, False) ----end mini
1.
0.028 s
OK
stdout:
---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ----end minimum: (0,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, False) ----end minimum: (1,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, False) (1,2: 1, False) ----end minimum: (2,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, False) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ----end minimum: (1,2: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ----end minimum: (2,0: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ----end minimum: (0,2: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, True) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ---- (0,2: 2, True) (1,2: 1, True) (0,3
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
stdout:
---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, False) ----end minimum: (1,0: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, False) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ----end minimum: (0,1: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ----end minimum: (2,0: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ---- (2,0: 3, True) (2,1: 4, False) ----end minimum: (0,2: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, False) ---- (0,2: 3, True) (1,2: 4, False) ----end minimum: (2,1: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, False) ---- (2,1: 4, True) (2,2: 5, False) ----end minimum: (1,2: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, True) ---- (2,1: 4, True) (2,2: 5, False) ---- (1,2: 4, True) (2,2: 5, False) ----end minimum: (2,2: 5, True)
Code: 03:44:09 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = A[0];
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:44:20 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = A[0][0] == 0;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:44:31 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0) existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = A[0][0] == 0;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
OK
stdout:
---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ----end minimum: (0,1: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ----end minimum: (2,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ----end minimum: (0,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, False) ----end minimum: (1,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, False) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ----end minimum: (0,3: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ----end minimum: (2,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, True) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ---- (2,2: 1, True) (3,2: 2, False) (2,3: 1, False) ----end mini
1.
0.032 s
OK
stdout:
---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ----end minimum: (0,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, False) ----end minimum: (1,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, False) (1,2: 1, False) ----end minimum: (2,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, False) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ----end minimum: (1,2: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ----end minimum: (2,0: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ----end minimum: (0,2: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, True) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ---- (0,2: 2, True) (1,2: 1, True) (0,3
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
stdout:
---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, False) ----end minimum: (1,0: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, False) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ----end minimum: (0,1: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ----end minimum: (2,0: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ---- (2,0: 3, True) (2,1: 4, False) ----end minimum: (0,2: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, False) ---- (0,2: 3, True) (1,2: 4, False) ----end minimum: (2,1: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, False) ---- (2,1: 4, True) (2,2: 5, False) ----end minimum: (1,2: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, True) ---- (2,1: 4, True) (2,2: 5, False) ---- (1,2: 4, True) (2,2: 5, False) ----end minimum: (2,2: 5, True)
Code: 03:45:00 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0)´ existsSomeZero = true;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = A[0][0] == 0;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:45:19 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
if(A[x][y] == 0){
existsSomeZero = true;
Console.WriteLine("existsSomeZero");
}
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = A[0][0] == 0;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.032 s
OK
stdout:
---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ----end minimum: (0,1: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ----end minimum: (2,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ----end minimum: (0,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, False) ----end minimum: (1,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, False) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ----end minimum: (0,3: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ----end minimum: (2,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, True) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ---- (2,2: 1, True) (3,2: 2, False) (2,3: 1, False) ----end mini
1.
0.032 s
OK
stdout:
---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ----end minimum: (0,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, False) ----end minimum: (1,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, False) (1,2: 1, False) ----end minimum: (2,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, False) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ----end minimum: (1,2: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ----end minimum: (2,0: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ----end minimum: (0,2: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, True) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ---- (0,2: 2, True) (1,2: 1, True) (0,3
1.
0.028 s
WRONG ANSWER,
got 5 expected 1
stdout:
---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, False) ----end minimum: (1,0: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, False) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ----end minimum: (0,1: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ----end minimum: (2,0: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ---- (2,0: 3, True) (2,1: 4, False) ----end minimum: (0,2: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, False) ---- (0,2: 3, True) (1,2: 4, False) ----end minimum: (2,1: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, False) ---- (2,1: 4, True) (2,2: 5, False) ----end minimum: (1,2: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, True) ---- (2,1: 4, True) (2,2: 5, False) ---- (1,2: 4, True) (2,2: 5, False) ----end minimum: (2,2: 5, True)
Code: 03:46:16 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = A[0][0] == 0;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:46:28 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = A[0][0] == 0;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:46:40 UTC,
cs,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = A[0][0] == 0;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
Compile error
Compilation failed: 1 error(s), 0 warnings Solution.cs(167,35): error CS1501: No overload for method `GetNode' takes `5' arguments Solution.cs(90,17): (Location of the symbol related to previous error)
Code: 03:46:59 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, );
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
bool existsSomeZero = A[0][0] == 0;
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:47:13 UTC,
cs,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Analysis
expand all
Example tests
1.
0.028 s
OK
stdout:
---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ----end minimum: (0,1: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ----end minimum: (2,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ----end minimum: (0,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, False) ----end minimum: (1,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, False) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ----end minimum: (0,3: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ----end minimum: (2,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, True) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ---- (2,2: 1, True) (3,2: 2, False) (2,3: 1, False) ----end mini
1.
0.028 s
OK
stdout:
---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ----end minimum: (0,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, False) ----end minimum: (1,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, False) (1,2: 1, False) ----end minimum: (2,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, False) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ----end minimum: (1,2: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ----end minimum: (2,0: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ----end minimum: (0,2: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, True) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ---- (0,2: 2, True) (1,2: 1, True) (0,3
1.
0.028 s
OK
stdout:
---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, False) ----end minimum: (1,0: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, False) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ----end minimum: (0,1: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ----end minimum: (2,0: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ---- (2,0: 3, True) (2,1: 4, False) ----end minimum: (0,2: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, False) ---- (0,2: 3, True) (1,2: 4, False) ----end minimum: (2,1: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, False) ---- (2,1: 4, True) (2,2: 5, False) ----end minimum: (1,2: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, True) ---- (2,1: 4, True) (2,2: 5, False) ---- (1,2: 4, True) (2,2: 5, False) ----end minimum: (2,2: 5, True) min 1 dist
Code: 03:47:22 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:47:51 UTC,
cs,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
User test case 1:
[[1]]
User test case 2:
[[0]]
User test case 3:
[[2]]
User test case 4:
[[10]]
Analysis
expand all
Example tests
1.
0.028 s
OK
stdout:
---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ----end minimum: (0,1: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ----end minimum: (2,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ----end minimum: (0,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, False) ----end minimum: (1,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, False) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ----end minimum: (0,3: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ----end minimum: (2,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, True) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ---- (2,2: 1, True) (3,2: 2, False) (2,3: 1, False) ----end mini
1.
0.032 s
OK
stdout:
---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ----end minimum: (0,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, False) ----end minimum: (1,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, False) (1,2: 1, False) ----end minimum: (2,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, False) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ----end minimum: (1,2: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ----end minimum: (2,0: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ----end minimum: (0,2: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, True) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ---- (0,2: 2, True) (1,2: 1, True) (0,3
1.
0.028 s
OK
stdout:
---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, False) ----end minimum: (1,0: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, False) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ----end minimum: (0,1: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ----end minimum: (2,0: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ---- (2,0: 3, True) (2,1: 4, False) ----end minimum: (0,2: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, False) ---- (0,2: 3, True) (1,2: 4, False) ----end minimum: (2,1: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, False) ---- (2,1: 4, True) (2,2: 5, False) ----end minimum: (1,2: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, True) ---- (2,1: 4, True) (2,2: 5, False) ---- (1,2: 4, True) (2,2: 5, False) ----end minimum: (2,2: 5, True) min 1 dist
expand all
User tests
1.
0.028 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0stdout:
---- (0,0: 0, True) ----end
1.
0.028 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0stdout:
---- (0,0: 10000000, True) ----end
1.
0.028 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0stdout:
---- (0,0: 0, True) ----end
1.
0.028 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at Solution.solution (System.Int32[][] A) [0x00000] in <filename unknown>:0 at SolutionWrapper.run (System.String input, System.String output) [0x00000] in <filename unknown>:0 at SolutionWrapper.Main (System.String[] args) [0x00000] in <filename unknown>:0stdout:
---- (0,0: 1, True) ----end
Code: 03:49:21 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if()
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:49:31 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
}
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:49:41 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
return
}
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:50:12 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
return Math.Min(total2, total5);
}
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:50:23 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
return Math.Min(node.Total2, node.Total5);
}
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:50:35 UTC,
cs,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
minDistance = Math.Min(node.Total2, node.Total5);
break;
}
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
User test case 1:
[[1]]
User test case 2:
[[0]]
User test case 3:
[[2]]
User test case 4:
[[10]]
Analysis
expand all
Example tests
1.
0.036 s
OK
stdout:
---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ----end minimum: (0,1: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ----end minimum: (2,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ----end minimum: (0,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, False) ----end minimum: (1,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, False) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ----end minimum: (0,3: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ----end minimum: (2,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, True) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ---- (2,2: 1, True) (3,2: 2, False) (2,3: 1, False) ----end mini
1.
0.028 s
OK
stdout:
---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ----end minimum: (0,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, False) ----end minimum: (1,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, False) (1,2: 1, False) ----end minimum: (2,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, False) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ----end minimum: (1,2: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ----end minimum: (2,0: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ----end minimum: (0,2: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, True) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ---- (0,2: 2, True) (1,2: 1, True) (0,3
1.
0.028 s
OK
stdout:
---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, False) ----end minimum: (1,0: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, False) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ----end minimum: (0,1: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ----end minimum: (2,0: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ---- (2,0: 3, True) (2,1: 4, False) ----end minimum: (0,2: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, False) ---- (0,2: 3, True) (1,2: 4, False) ----end minimum: (2,1: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, False) ---- (2,1: 4, True) (2,2: 5, False) ----end minimum: (1,2: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, True) ---- (2,1: 4, True) (2,2: 5, False) ---- (1,2: 4, True) (2,2: 5, False) ----end minimum: (2,2: 5, True) min 1 dist
expand all
User tests
1.
0.028 s
OK
function result: 0
function result: 0
stdout:
---- (0,0: 0, True) ----end
1.
0.024 s
OK
function result: 0
function result: 0
stdout:
---- (0,0: 10000000, True) ----end min 1 dist
1.
0.028 s
OK
function result: 0
function result: 0
stdout:
---- (0,0: 0, True) ----end
1.
0.028 s
OK
function result: 1
function result: 1
stdout:
---- (0,0: 1, True) ----end
Code: 03:53:00 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
minDistance = no
break;
}
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:53:03 UTC,
cs,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
minDistance = node.Distance;
break;
}
minimum.SetPicked();
shortest.Add(minimum);
Console.WriteLine("minimum:");
printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
User test case 1:
[[1]]
User test case 2:
[[0]]
User test case 3:
[[2]]
User test case 4:
[[10]]
Analysis
expand all
Example tests
1.
0.028 s
OK
stdout:
---- (0,0: 0, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ----end minimum: (0,1: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, False) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ----end minimum: (2,0: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, False) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ----end minimum: (0,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, False) (0,3: 1, False) ----end minimum: (1,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, False) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ----end minimum: (0,3: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, False) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ----end minimum: (2,2: 1, True) ---- (0,0: 0, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 1, True) (1,1: 2, False) ---- (0,1: 1, True) (1,1: 2, False) (0,2: 1, True) ---- (2,0: 1, True) (3,0: 3, False) (2,1: 2, False) ---- (0,2: 1, True) (1,2: 1, True) (0,3: 1, True) ---- (1,2: 1, True) (2,2: 1, True) (1,3: 2, False) ---- (0,3: 1, True) (1,3: 2, False) ---- (2,2: 1, True) (3,2: 2, False) (2,3: 1, False) ----end mini
1.
0.040 s
OK
stdout:
---- (0,0: 1, True) (1,0: 1, False) (0,1: 1, False) ----end minimum: (1,0: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, False) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ----end minimum: (0,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, False) ---- (0,1: 1, True) (1,1: 1, False) (0,2: 2, False) ----end minimum: (1,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, False) (1,2: 1, False) ----end minimum: (2,1: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, False) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ----end minimum: (1,2: 1, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, False) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ----end minimum: (2,0: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, False) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ----end minimum: (0,2: 2, True) ---- (0,0: 1, True) (1,0: 1, True) (0,1: 1, True) ---- (1,0: 1, True) (2,0: 2, True) (1,1: 1, True) ---- (0,1: 1, True) (1,1: 1, True) (0,2: 2, True) ---- (1,1: 1, True) (2,1: 1, True) (1,2: 1, True) ---- (2,1: 1, True) (3,1: 2, False) (2,2: 2, False) ---- (1,2: 1, True) (2,2: 2, False) (1,3: 2, False) ---- (2,0: 2, True) (3,0: 2, False) (2,1: 1, True) ---- (0,2: 2, True) (1,2: 1, True) (0,3
1.
0.028 s
OK
stdout:
---- (0,0: 1, True) (1,0: 2, False) (0,1: 2, False) ----end minimum: (1,0: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, False) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ----end minimum: (0,1: 2, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, False) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ----end minimum: (2,0: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, False) ---- (2,0: 3, True) (2,1: 4, False) ----end minimum: (0,2: 3, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, False) ---- (0,2: 3, True) (1,2: 4, False) ----end minimum: (2,1: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, False) ---- (2,1: 4, True) (2,2: 5, False) ----end minimum: (1,2: 4, True) ---- (0,0: 1, True) (1,0: 2, True) (0,1: 2, True) ---- (1,0: 2, True) (2,0: 3, True) (1,1: 10000000, False) ---- (0,1: 2, True) (1,1: 10000000, False) (0,2: 3, True) ---- (2,0: 3, True) (2,1: 4, True) ---- (0,2: 3, True) (1,2: 4, True) ---- (2,1: 4, True) (2,2: 5, False) ---- (1,2: 4, True) (2,2: 5, False) ----end minimum: (2,2: 5, True) min 1 dist
expand all
User tests
1.
0.028 s
OK
function result: 0
function result: 0
stdout:
---- (0,0: 0, True) ----end
1.
0.028 s
OK
function result: 1
function result: 1
stdout:
---- (0,0: 10000000, True) ----end min 1 dist
1.
0.028 s
OK
function result: 0
function result: 0
stdout:
---- (0,0: 0, True) ----end
1.
0.028 s
OK
function result: 1
function result: 1
stdout:
---- (0,0: 1, True) ----end
Code: 03:53:18 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
minDistance = node.Distance;
break;
}
minimum.SetPicked();
shortest.Add(minimum);
//Console.WriteLine("minimum:");
//printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:53:33 UTC,
cs,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
//printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
//printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
//printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
//Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
minDistance = node.Distance;
break;
}
minimum.SetPicked();
shortest.Add(minimum);
//Console.WriteLine("minimum:");
//printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
User test case 1:
[[1]]
User test case 2:
[[0]]
User test case 3:
[[2]]
User test case 4:
[[10]]
Analysis
expand all
Example tests
1.
0.032 s
OK
stdout:
---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
1.
0.032 s
OK
stdout:
---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
1.
0.032 s
OK
stdout:
---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- min 1 dist
expand all
User tests
1.
0.032 s
OK
function result: 0
function result: 0
stdout:
----
1.
0.028 s
OK
function result: 1
function result: 1
stdout:
---- min 1 dist
1.
0.032 s
OK
function result: 0
function result: 0
stdout:
----
1.
0.032 s
OK
function result: 1
function result: 1
stdout:
----
Code: 03:53:39 UTC,
cs,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
//Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
//printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
//printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
//printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
//Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
minDistance = node.Distance;
break;
}
minimum.SetPicked();
shortest.Add(minimum);
//Console.WriteLine("minimum:");
//printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
User test case 1:
[[1]]
User test case 2:
[[0]]
User test case 3:
[[2]]
User test case 4:
[[10]]
Analysis
expand all
User tests
1.
0.024 s
OK
function result: 0
function result: 0
1.
0.028 s
OK
function result: 1
function result: 1
stdout:
min 1 dist
1.
0.024 s
OK
function result: 0
function result: 0
1.
0.024 s
OK
function result: 1
function result: 1
Code: 03:53:57 UTC,
cs,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
//Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
//printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
//printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
//printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
//Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
minDistance = node.Distance;
break;
}
minimum.SetPicked();
shortest.Add(minimum);
//Console.WriteLine("minimum:");
//printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
//Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
Code: 03:53:58 UTC,
cs,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
//Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
//printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
//printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
//printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
//Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
minDistance = node.Distance;
break;
}
minimum.SetPicked();
shortest.Add(minimum);
//Console.WriteLine("minimum:");
//printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
//Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
User test case 1:
[[1]]
User test case 2:
[[0]]
User test case 3:
[[2]]
User test case 4:
[[10]]
Analysis
expand all
User tests
1.
0.024 s
OK
function result: 0
function result: 0
1.
0.024 s
OK
function result: 1
function result: 1
1.
0.024 s
OK
function result: 0
function result: 0
1.
0.024 s
OK
function result: 1
function result: 1
Code: 03:55:12 UTC,
cs,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
//Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
//printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
//printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
//printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
//Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
minDistance = node.Distance;
break;
}
minimum.SetPicked();
shortest.Add(minimum);
//Console.WriteLine("minimum:");
//printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
//Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
User test case 1:
[[1]]
User test case 2:
[[0]]
User test case 3:
[[2]]
User test case 4:
[[10]]
Analysis
expand all
User tests
1.
0.028 s
OK
function result: 0
function result: 0
1.
0.028 s
OK
function result: 1
function result: 1
1.
0.028 s
OK
function result: 0
function result: 0
1.
0.028 s
OK
function result: 1
function result: 1
Code: 03:55:16 UTC,
cs,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
//Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
//printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
//printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
//printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
//Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
minDistance = node.Distance;
break;
}
minimum.SetPicked();
shortest.Add(minimum);
//Console.WriteLine("minimum:");
//printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
//Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}
User test case 1:
[[1]]
User test case 2:
[[0]]
User test case 3:
[[2]]
User test case 4:
[[10]]
Analysis
expand all
User tests
1.
0.028 s
OK
function result: 0
function result: 0
1.
0.024 s
OK
function result: 1
function result: 1
1.
0.028 s
OK
function result: 0
function result: 0
1.
0.028 s
OK
function result: 1
function result: 1
Code: 03:55:19 UTC,
cs,
final,
score:
55
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
using System;
using System.Collections.Generic;
using System.Linq;
// you can also use other imports, for example:
// using System.Collections.Generic;
// you can write to stdout for debugging purposes, e.g.
// Console.WriteLine("this is a debug message");
class CountDivisor{
private Dictionary<int,int> divisorsOf2;
private Dictionary<int,int> divisorsOf5;
public CountDivisor(){
divisorsOf2 = new Dictionary<int,int>(10000);
divisorsOf5 = new Dictionary<int,int>(10000);
}
private int getCountDivisor(int n, int d){
int count = 0;
while(n%d == 0){
n/=d;
count++;
}
return count;
}
public int getCountDivisors2(int n){
if(divisorsOf2.ContainsKey(n)) return divisorsOf2[n];
var count = getCountDivisor(n, 2);
divisorsOf2[n] = count;
return count;
}
public int getCountDivisors5(int n){
if(divisorsOf5.ContainsKey(n)) return divisorsOf5[n];
var count = getCountDivisor(n, 5);
divisorsOf5[n] = count;
return count;
}
}
class Node{
public int X {get;}
public int Y {get;}
public int Total2 {get;}
public int Total5 {get;}
public int Distance {get; private set;}
public bool Picked {get; private set;}
public Node(int x, int y, int d, int total2, int total5){
X = x;
Y = y;
Distance = d;
Total2 = total2;
Total5 = total5;
Picked = false;
}
public void SetPicked(){
Picked = true;
}
}
class NodeRepository{
private const int ZERO = 0;
private const int BIG_DISTANCE = 10000000;
private CountDivisor countDivisor;
private Dictionary<Tuple<int,int>, Node> nodes;
public NodeRepository(){
countDivisor = new CountDivisor();
nodes = new Dictionary<Tuple<int,int>, Node>(1000);
}
public Node GetNode(int[][] A, int x, int y, int total2, int total5, ref bool existsSomeZero){
var key = Tuple.Create(x, y);
if(nodes.ContainsKey(key)) return nodes[key];
var currValue = A[x][y];
if(currValue == ZERO){
existsSomeZero = true;
var newNodeZero = new Node(x, y, BIG_DISTANCE, 0, 0);
nodes[key] = newNodeZero;
return newNodeZero;
}
total2 += countDivisor.getCountDivisors2(currValue);
total5 += countDivisor.getCountDivisors5(currValue);
var distance = Math.Min(total2, total5);
var newNode = new Node(x, y, distance, total2, total5);
nodes[key] = newNode;
return newNode;
}
}
class Solution {
private const int BIG_DISTANCE = 10000000;
private NodeRepository nodeRepository;
public Solution(){
nodeRepository = new NodeRepository();
}
private void printNode(Node node){
if(node == null) Console.WriteLine("null");
else
Console.WriteLine("(" + node.X + "," + node.Y + ": " + node.Distance + ", " + node.Picked + ")");
}
// Get minimum from neighbors
private Node getMimimumNoPicked(int[][] A, List<Node> shortest
, int maxRow, int maxCol, ref bool existsSomeZero){
var minDistance = int.MaxValue;
Node nodeMinDistance = null;
foreach(var node in shortest){
//Console.WriteLine("----");
var x = node.X;
var y = node.Y;
var total2 = node.Total2;
var total5 = node.Total5;
//printNode(node);
if(x <= maxRow - 2){
var down = nodeRepository.GetNode(A, x+1, y, total2, total5, ref existsSomeZero);
//printNode(down);
if(!down.Picked){
if(down.Distance < minDistance){
minDistance = down.Distance;
nodeMinDistance = down;
}
}
}
if(y <= maxCol - 2){
var right = nodeRepository.GetNode(A, x, y+1, total2, total5, ref existsSomeZero);
//printNode(right);
if(!right.Picked){
if(right.Distance < minDistance){
minDistance = right.Distance;
nodeMinDistance = right;
}
}
}
}
//Console.WriteLine("----end");
return nodeMinDistance;
}
public int solution(int[][] A) {
int n = A.Length;
bool existsSomeZero = false;
var node = nodeRepository.GetNode(A, 0, 0, 0, 0, ref existsSomeZero);
node.SetPicked();
var shortest = new List<Node>(250000);
shortest.Add(node);
int minDistance = 0;
for(int i=0; i<100000000; i++){
var minimum = getMimimumNoPicked(A, shortest, n, n, ref existsSomeZero);
if(minimum == null){
minDistance = node.Distance;
break;
}
minimum.SetPicked();
shortest.Add(minimum);
//Console.WriteLine("minimum:");
//printNode(minimum);
if(minimum.X == n-1 && minimum.Y == n-1){
minDistance = minimum.Distance;
break;
}
}
if(existsSomeZero){
//Console.WriteLine("min 1 dist");
return Math.Min(1, minDistance);
}
return minDistance;
}
}Analysis summary
The following issues have been detected: timeout errors.
Analysis
Detected time complexity:
O(N**2*2**N*log(max(max(A))))
expand all
Correctness tests
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
4.
0.024 s
OK
5.
0.024 s
OK
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
4.
0.028 s
OK
5.
0.028 s
OK
6.
0.024 s
OK
7.
0.028 s
OK
8.
0.032 s
OK
9.
0.032 s
OK
1.
0.024 s
OK
2.
0.028 s
OK
3.
0.028 s
OK
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
4.
0.032 s
OK
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
4.
0.032 s
OK
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.028 s
OK
1.
0.024 s
OK
2.
0.024 s
OK
3.
0.024 s
OK
4.
0.024 s
OK
5.
0.024 s
OK
6.
0.028 s
OK
7.
0.028 s
OK
8.
0.024 s
OK
9.
0.032 s
OK
1.
0.024 s
OK
2.
0.028 s
OK
3.
0.024 s
OK
expand all
Performance tests
1.
0.032 s
OK
1.
0.060 s
OK
2.
2.052 s
TIMEOUT ERROR,
running time: 2.05 sec., time limit: 0.10 sec.
3.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.10 sec.
medium_alternating_diagonals_2_5
alternating diagonals consist of 2 or 5
alternating diagonals consist of 2 or 5
✘
TIMEOUT ERROR
running time: >6.00 sec., time limit: 0.10 sec.
running time: >6.00 sec., time limit: 0.10 sec.
1.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.10 sec.
big_zero_result
all elements in A are neither dividable by 2 or 5; length of A is close to 500
all elements in A are neither dividable by 2 or 5; length of A is close to 500
✘
TIMEOUT ERROR
running time: >6.00 sec., time limit: 0.10 sec.
running time: >6.00 sec., time limit: 0.10 sec.
1.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.10 sec.
2.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.13 sec.
3.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.19 sec.
4.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.29 sec.
5.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.40 sec.
big_all_dividable
all elements in A are dividable by either power of 2 or 5; length of A is close to 500
all elements in A are dividable by either power of 2 or 5; length of A is close to 500
✘
TIMEOUT ERROR
running time: >6.00 sec., time limit: 0.10 sec.
running time: >6.00 sec., time limit: 0.10 sec.
1.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.10 sec.
2.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.14 sec.
3.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.24 sec.
4.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.34 sec.
5.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.43 sec.
1.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.45 sec.
2.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.43 sec.
3.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.42 sec.
4.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.42 sec.
5.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.43 sec.
big_corner_cases
tests with corner cases values, maximal A size
tests with corner cases values, maximal A size
✘
TIMEOUT ERROR
running time: >6.00 sec., time limit: 0.58 sec.
running time: >6.00 sec., time limit: 0.58 sec.
1.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.58 sec.
2.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.27 sec.
big_exact_result
tests with defined result; length of A is close to 500
tests with defined result; length of A is close to 500
✘
TIMEOUT ERROR
running time: >6.00 sec., time limit: 0.10 sec.
running time: >6.00 sec., time limit: 0.10 sec.
1.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.10 sec.
2.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.10 sec.
3.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.10 sec.
4.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.13 sec.
5.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.13 sec.
6.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.13 sec.
7.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.18 sec.
8.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.18 sec.
9.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.18 sec.
10.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.24 sec.
11.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.24 sec.
12.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.26 sec.
13.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.32 sec.
14.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.32 sec.
15.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.34 sec.
alternating_diagonals_2_5
alternating diagonals consist of 2 or 5
alternating diagonals consist of 2 or 5
✘
TIMEOUT ERROR
running time: >6.00 sec., time limit: 0.29 sec.
running time: >6.00 sec., time limit: 0.29 sec.
1.
6.000 s
TIMEOUT ERROR,
running time: >6.00 sec., time limit: 0.29 sec.