tc 146 2 RectangularGrid(数学推导）

SRM 146 2 500RectangularGrid

---

Problem Statement

Given the width and height of a rectangular grid, return the total number of rectangles (NOT counting squares) that can be found on this grid.

For example, width = 3, height = 3 (see diagram below):

 __ __ __
|__|__|__|
|__|__|__|
|__|__|__|

In this grid, there are 4 2x3 rectangles, 6 1x3 rectangles and 12 1x2 rectangles. Thus there is a total of 4 + 6 + 12 = 22 rectangles. Note we don't count 1x1, 2x2 and 3x3 rectangles because they are squares.

Definition

• ClassRectangularGrid
• MethodcountRectangles
• Parametersint , int
• Returnslong long
• Method signaturelong long countRectangles(int width, int height)

(be sure your method is public)

Limits

• Time limit (s)2.000
• Memory limit (MB)64

Notes

• rectangles with equals sides (squares) should not be counted.

Constraints

• width and height will be between 1 and 1000 inclusive.

Test cases

1.  

   • width3
   • height3

    

   Returns22

    

   See above
2.  

   • width5
   • height2

    

   Returns31

    

    __ __ __ __ __
   |__|__|__|__|__|
   |__|__|__|__|__|
   

   In this grid, there is one 2x5 rectangle, 2 2x4 rectangles, 2 1x5 rectangles, 3 2x3 rectangles, 4 1x4 rectangles, 6 1x3 rectangles and 13 1x2 rectangles. Thus there is a total of 1 + 2 + 2 + 3 + 4 + 6 + 13 = 31 rectangles.

3.  

   • width10
   • height10

    

   Returns2640

4.  

   • width1
   • height1

    

   Returns0

5.  

   • width592
   • height964

    

   Returns81508708664

    #include <cstdio>
    #include <cmath>
    #include <cstring>
    #include <ctime>
    #include <iostream>
    #include <algorithm>
    #include <set>
    #include <vector>
    #include <sstream>
    #include <typeinfo>
    #include <fstream>
   
    using namespace std;
    typedef long long ll ;
    class RectangularGrid {
        public:
        long long countRectangles(int l , int r) {
            if (l > r) swap (l , r ) ;
          //  printf ("l = %d , r = %d\n" , l , r ) ;
            ll all = (1ll *l*l*r*r + 1ll *l*r*r + 1ll *r*l*l + 1ll *r*l) /  ;
            ll sum = 1ll * l * (l - ) * (l + ) /  + 1ll * (r - l + ) * l * (l + ) /  ;
         //   printf ("all = %lld , sum = %lld\n" , all , sum) ;
            return all - sum ;
        }
    };
   
    // CUT begin
    ifstream data("RectangularGrid.sample");
   
    string next_line() {
        string s;
        getline(data, s);
        return s;
    }
   
    template <typename T> void from_stream(T &t) {
        stringstream ss(next_line());
        ss >> t;
    }
   
    void from_stream(string &s) {
        s = next_line();
    }
   
    template <typename T>
    string to_string(T t) {
        stringstream s;
        s << t;
        return s.str();
    }
   
    string to_string(string t) {
        return "\"" + t + "\"";
    }
   
    bool do_test(int width, int height, long long __expected) {
        time_t startClock = clock();
        RectangularGrid *instance = new RectangularGrid();
        long long __result = instance->countRectangles(width, height);
        double elapsed = (double)(clock() - startClock) / CLOCKS_PER_SEC;
        delete instance;
   
        if (__result == __expected) {
            cout << "PASSED!" << " (" << elapsed << " seconds)" << endl;
            return true;
        }
        else {
            cout << "FAILED!" << " (" << elapsed << " seconds)" << endl;
            cout << "           Expected: " << to_string(__expected) << endl;
            cout << "           Received: " << to_string(__result) << endl;
            return false;
        }
    }
   
    int run_test(bool mainProcess, const set<int> &case_set, const string command) {
        int cases = , passed = ;
        while (true) {
            if (next_line().find("--") != )
                break;
            int width;
            from_stream(width);
            int height;
            from_stream(height);
            next_line();
            long long __answer;
            from_stream(__answer);
   
            cases++;
            if (case_set.size() >  && case_set.find(cases - ) == case_set.end())
                continue;
   
            cout << "  Testcase #" << cases -  << " ... ";
            if ( do_test(width, height, __answer)) {
                passed++;
            }
        }
        if (mainProcess) {
            cout << endl << "Passed : " << passed << "/" << cases << " cases" << endl;
            int T = time(NULL) - ;
            double PT = T / 60.0, TT = 75.0;
            cout << "Time   : " << T /  << " minutes " << T %  << " secs" << endl;
            cout << "Score  : " <<  * (0.3 + (0.7 * TT * TT) / (10.0 * PT * PT + TT * TT)) << " points" << endl;
        }
        return ;
    }
   
    int main(int argc, char *argv[]) {
        cout.setf(ios::fixed, ios::floatfield);
        cout.precision();
        set<int> cases;
        bool mainProcess = true;
        for (int i = ; i < argc; ++i) {
            if ( string(argv[i]) == "-") {
                mainProcess = false;
            } else {
                cases.insert(atoi(argv[i]));
            }
        }
        if (mainProcess) {
            cout << "RectangularGrid (500 Points)" << endl << endl;
        }
        return run_test(mainProcess, cases, argv[]);
    }
    // CUT end

   已知一个长 l , 宽 r 的由１×１的单位矩阵构成的矩阵，问其中有多少个长方形？

   那么我们只要求出其中矩阵的总个数n , 和正方形数m,然后n - m就是答案。

   ｎ＝ ｌ*ｒ　＋　ｌ×（ｒ×（ｒ－１））／２　＋　ｒ×（ｌ×（ｌ－１））／２　＋　ｌ×ｒ×（ｌ－１）×（ｒ－１）／４

   　＝（ｌ×ｌ×ｒ×ｒ＋ｌ×ｒ×ｒ＋ｒ×ｌ×ｌ＋ｒ×ｌ）／４；

   ｍ＝２×（１＋２×３／２＋４×３／２＋……＋ｌ×（ｌ－１）／２）　＋　（ｒ－ｌ＋１）×ｌ×（ｌ＋１）／２；

   　＝ｌ×（ｌ＋１）×（２×ｌ＋１）／６　＋　（ｒ－ｌ）×ｌ×（ｌ＋１）／２；

   ＰＳ：

   1^2 + 2^2 + 3^2 + 4^2 + 5^2 +……＋n^2 = n*(n + 1)*(2*n+1)/6;

   证明：（来自百度文库）

   想像一个有圆圈构成的正三角形，

   第一行1个圈，圈内的数字为1

   第二行2个圈，圈内的数字都为2，

   以此类推

   第n行n个圈，圈内的数字都为n，

   我们要求的平方和，

   就转化为了求这个三角形所有圈内数字的和。

   设这个数为r

   下面将这个三角形顺时针旋转120度，

   得到第二个三角形

   再将第二个三角形顺时针旋转120度，得到第三个三角形.

   然后，将这三个三角形对应的圆圈内的数字相加，

   我们神奇的发现所有圈内的数字都变成了

   2n+1

   而总共有几个圈呢，这是一个简单的等差数列求和

   1+2+……+n=n(n+1)/2

   于是

   3r=[n(n+1)/2]*(2n+1)

   r=n(n+1)(2n+1)/6