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[] { 7, 16, 20, 24 }, new int[] { 5, 14, 18, 22 }, 
                                            new int[] { 6, 7, 10, 15 }, new int[]{ 6, 7, 10, 15 }, 
                                            new int[]{ 3, 7, 11, 18 }, new int[]{ 4, 8, 12, 19 } };
            //result should be 7
            Console.WriteLine(new Solution().solution(Testcase, 24));
        }
    }

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

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

            //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] += 1;
                        flgFind = true;
                        break;
                    }
                }
                if(flgFind == false)
                    buckets.Add(oneClock, 1);

            }

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

            return result;

        }

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

                flgJ = false;
                for (int j = 0; j < hands; j++)
                {
                    int newS = source[(i + j) % hands] + subValue;
                    if (newS <= 0)
                        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.