rotate the clock

A program test：

You are given N round clocks.

Every clock has M hands, and these hands can point to positions 1, 2, 3, ..., P (yes, these represent numbers around each face). The clocks are represented by the matrix A consisting of N rows and M columns of integers. The first row represents the hands of the first clock, and so on.

For example, you are given matrix A consisting of five rows and two columns, and P = 4:

  A[0][0] = 1    A[0][1] = 2
  A[1][0] = 2    A[1][1] = 4
  A[2][0] = 4    A[2][1] = 3
  A[3][0] = 2    A[3][1] = 3
  A[4][0] = 1    A[4][1] = 3

You can rotate the clocks to obtain several clocks that look identical. For example, if you rotate the third, fourth and fifth clocks you can obtain the following clocks:

After rotation, you have four pairs of clocks that look the same: (1, 3), (1, 4), (2, 5) and (3, 4).

type TMatrix = array of array of longint;

Write a function:

int solution(int **A, int N, int M, int P);

int solution(NSMutableArray *A, int P);

int solution(const vector< vector<int> > &A, int P);

class Solution { int solution(int[][] A, int P); }

class Solution { public int solution(int[][] A, int P); }

object Solution { def solution(A: Array[Array[Int]], P: Int): Int }

function solution(A, P);

function solution(A, P)

function solution($A, $P);

function solution(A: TMatrix; N: longint; M: longint; P: longint): longint;

def solution(A, P)

sub solution { my ($A, $P)=@_; my @A=@$A; ... }

def solution(a, p)

Private Function solution ( A As Integer()(), P As Integer ) as Integer

that, given a zero-indexed matrix A consisting of N rows and M columns of integers and integer P, returns the maximal number of pairs of clocks that can look the same after rotation.

For example, given the following array A and P = 4:

    A[0][0] = 1     A[0][1] = 2
    A[1][0] = 2     A[1][1] = 4
    A[2][0] = 4     A[2][1] = 3
    A[3][0] = 2     A[3][1] = 3
    A[4][0] = 1     A[4][1] = 3

the function should return 4, as explained above.

Assume that:

• N is an integer within the range [1..500];
• M is an integer within the range [1..500];
• P is an integer within the range [1..1,000,000,000];
• each element of matrix A is an integer within the range [1..P];
• the elements of each row of matrix A are all distinct.

Complexity:

• expected worst-case time complexity is O(N*M*log(M)+N*log(N));
• expected worst-case space complexity is O(N*M).

Here is my solution:

     class Program
     {
         static void Main(string[] args)
         {
             int[][] Testcase = new int[][] { new int[] { , , ,  }, new int[] { , , ,  },
                                             new int[] { , , ,  }, new int[]{ , , ,  },
                                             new int[]{ , , ,  }, new int[]{ , , ,  } };
             //result should be 7
             Console.WriteLine(new Solution().solution(Testcase, ));
         }
     }

     class Solution
     {
         public int solution(int[][] A, int P)
         {
             int result = ;
             int hands =  A[].Length;

             Dictionary<int[], int> buckets = new Dictionary<int[], int>();
             buckets.Add (A[],);

             //fill the buckets
             bool flgFind = false;
             foreach(int[] oneClock in A)
             {
                 flgFind = false;
                 foreach(int[] bucket in buckets.Keys)
                 {
                     if (CanbeRotatedToEqual(oneClock, bucket,P) == true)
                     {
                         buckets[bucket] += ;
                         flgFind = true;
                         break;
                     }
                 }
                 if(flgFind == false)
                     buckets.Add(oneClock, );

             }

             //calculate the total pairs
             foreach (int k in buckets.Values)
                 result += k * (k - ) / ;

             return result;

         }

         bool CanbeRotatedToEqual(int[] source, int[] target, int P)
         {
             bool flgJ = false;
             int hands = source.Length;
             for (int i = ; i < hands; i++)
             {
                 int subValue = target[] - source[i];

                 flgJ = false;
                 for (int j = ; j < hands; j++)
                 {
                     int newS = source[(i + j) % hands] + subValue;
                     if (newS <= )
                         newS += P;
                     if (newS != target[j])
                     {
                         flgJ = true;
                         break;
                     }
                 }
                 //When flgJ is still false, that means after the source clock rotates subValue steps,
                 //it is identical with the target one.
                 if (flgJ == false)
                     return true;
             }
             //if this loop end normally, that means the source clock cannot rotate to the target one.
             return false;
         }
     }

2013/8/18: This is not valid version.