• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>
            隨筆 - 68  文章 - 57  trackbacks - 0
            <2025年5月>
            27282930123
            45678910
            11121314151617
            18192021222324
            25262728293031
            1234567

            常用鏈接

            留言簿(8)

            隨筆分類(74)

            隨筆檔案(68)

            搜索

            •  

            最新評論

            閱讀排行榜

            評論排行榜

            好久不寫了啊,最近打算重新啟用這個blog。就先寫這個題目吧,滿經典的。
            【題目大意】
              m * n的區域內,每個整數坐標都有整點,問以這些整點為端點能夠形成多少個三角形。(0 < m, n <= 1000)

            【題目分析】
              這個題目乍一看挺簡單的,但是想做對還是要仔細的思考下的。補集轉化的思想,求出所有共線的三元組,然后用總數減掉就是答案了,關鍵就是如何求共線三元組。x坐標相同和y坐標相同的比較好計算,在一條斜線的就不好算了,畫個圖發現,即使斜率相同的線,經過的格點數可能各不相同。思路當然還是枚舉y / x(不同的y / x確定了不同的矩形區域),之后如何有效的計算,我采用的方法可能有些麻煩,有點類容斥的方法。以斜率為a / b為例,(a, b) = g,那么m * n的區域內一定有(m - a + 1) * (n - b + 1)個那么大的矩形,這樣的矩形經過的格點數是(g + 1);然后因為同等斜率小一點的矩形(a - a / g, b - b / g)也是存在的,個數同樣可以統計出來,但是有些大矩形包括了,要去掉;因此就采用這種思想,先求出大矩形的個數,然后依次往下減,就可以避免重復計數了。雖然這樣復雜度有點高,不過極限數據還是比較快的跑出來了。
              說的可能不太清楚,具體代碼如下:
             1 #include <cstdio>
             2 #include <iostream>
             3 using namespace std;
             4 const int N = 1024;
             5 
             6 bool tag[N][N];
             7 long long calc(long long n)
             8 {
             9     if (n <= 2)
            10         return 0;
            11     return n * (n - 1* (n - 2/ 6;
            12 }
            13 int gcd(int a, int b)
            14 {
            15     return b == 0 ? a : gcd(b, a % b);
            16 }
            17 
            18 int main()
            19 {
            20     int m, n, g, a, b, timer = 1, cnt[N], ta, tb;
            21     long long ans;
            22 
            23     while (scanf("%d %d"&m, &n) == 2)
            24     {
            25         memset(tag, 0sizeof(tag));
            26         if (m == 0 && n == 0)
            27             break;
            28         ans = calc((m + 1* (n + 1)) - calc(m + 1* (n + 1- calc(n + 1* (m + 1);
            29         for (int i = m; i >= 1; i--)
            30             for (int j = n; j >= 1; j--)
            31             {
            32                 g = gcd(i, j);
            33                 a = i / g, b = j / g;
            34                 if (tag[a][b])      continue;
            35                 memset(cnt, 0sizeof(cnt));
            36                 tag[a][b] = 1;
            37                 a = i, b = j;
            38                 ta = i / g, tb = j / g;
            39                 for (int k = g; k >= 2; k--)
            40                 {
            41                     cnt[k] += (m - a + 1* (n - b + 1);
            42                     ans -= calc(k + 1* cnt[k] * 2;
            43                     for (int t = 1; t <= k - 2; t++)
            44                         cnt[k-t] -= (t + 1* cnt[k];
            45                     a -= ta, b -= tb;
            46                 }
            47             }
            48         cout << "Case " << timer++ << "" << ans << endl;
            49     }
            50 
            51     return 0;
            52 }
            53 
            posted @ 2009-10-15 19:54 sdfond 閱讀(372) | 評論 (0)編輯 收藏

            這個題目去年就過了,用得是狀態壓縮dp,不過沒用dfs預處理,當時做得不是很明白,還是參考網上的一個代碼做的。
            現在重新做了一下這個題目,請教了icecream,學會了一個很簡練的做法,而且比較好理解還好寫。
            首先還是狀態的表示,用0表示沒有放木塊,用1表示放了木塊。此外,對于一個橫放的木塊,對應的兩位都用1表示;對于一個豎放的木塊,第一行用1表示,第二行用0表示。這只是一種設狀態的方式,當然還有別的設法,但是這種方法在接下來就會發現優點。

            狀態表示完就要處理轉移了,如何判斷一個轉移是否合法比較難辦,用一個dfs卻可以簡潔的解決這個問題。
            對于上一行到下一行的轉移,規定上一行一定填滿,這樣有三種方式:
                dfs(col + 1, (s1 << 1) | 1, s2 << 1, n);
                dfs(col + 1, s1 << 1, (s2 << 1) | 1, n);
                dfs(col + 2, (s1 << 2) | 3, (s2 << 2) | 3, n);
            第一種上面是1,那么下面一定是0,表示是一個豎放的木塊。
            第二種上面是0,就是說這個位置一定是一個豎放木塊的下半截,那么下一行肯定是要另起一行了,放一個豎放或者橫放的木塊都必須是1。
            第三種相當于上下兩行各放一個橫木塊。
            實現的時候我用了一個vector記錄每個狀態所有可行的轉移,這樣在dp的時候可以加快一些效率。

            還有一個問題需要考慮,那就是初值和最終的結果。如果尋找合法狀態,依然比較麻煩,假設共有n行,可以分別在這n行上下新加兩行。下面一行都是1,由于第n行肯定要填滿,這樣新加的全1的行就相當于頂住了第n行使其沒有凸出(有凸出那么第n+1行有0),而通過第n行到第n+1行轉移保留了所有合法狀態;同理最上面加的那行保證第一行沒有凸出。最后第n+1行對應全1的狀態就是最終的結果了。通過新加行巧妙地解決了初值和終值。

            實現的時候也需要注意一下,在TSP問題中,外層循環是狀態,內層是點,之所以這樣寫因為在枚舉點的時候,可能會從比當前編號大的點轉移,但是由于無論怎樣轉移過來的狀態肯定比當前狀態小(去掉了1),所以先從小到大枚舉狀態就保證轉移過來的狀態一定是算過的。而這個題目里面正好反過來,因為狀態可能從比當前狀態大的狀態轉移過來,而行數肯定是從編號小的行轉移,因此先枚舉行就能保證轉移過來的狀態一定是更新過的。


            #include <cstdio>
            #include 
            <vector>
            #include 
            <algorithm>
            using namespace std;
            const int N = 11;

            vector
            <int> g[1<<N];
            long long dp[N+2][1<<N];

            void dfs(int col, int s1, int s2, int n)
            {
                
            if (col >= n)
                {
                    
            if (s1 < (1 << n) && s2 < (1 << n))
                        g[s2].push_back(s1);
                    
            return;
                }
                dfs(col 
            + 1, (s1 << 1| 1, s2 << 1, n);
                dfs(col 
            + 1, s1 << 1, (s2 << 1| 1, n);
                dfs(col 
            + 2, (s1 << 2| 3, (s2 << 2| 3, n);
            }
            long long calc(int m, int n)
            {
                
            if (m < n)  swap(m, n);
                dfs(
            000, n);
                
            int state = 1 << n;

                dp[
            0][0= 1;
                
            for (int i = 1; i <= m + 1; i++)
                    
            for (int s = 0; s < state; s++)
                        
            for (int j = 0; j < g[s].size(); j++)
                            dp[i][s] 
            += dp[i-1][g[s][j]];
                
            return dp[m+1][state-1];
            }

            int main()
            {
                
            int m, n;

                
            while (scanf("%d %d"&m, &n) == 2)
                {
                    
            if (m == 0 && n == 0)
                        
            break;
                    
            for (int i = 0; i < (1 << N); i++)
                        g[i].clear();
                    memset(dp, 
            0sizeof(dp));
                    printf(
            "%I64d\n", calc(m, n));
                }

                
            return 0;
            }
            posted @ 2009-07-31 08:12 sdfond 閱讀(2319) | 評論 (1)編輯 收藏
            【題目大意】
              定義兩個三元組I(xi, yi, zi)和J(xj, yj, zj),他們的差為D(I, J) = max{xi - xj, yi - yj, zi - zj} - min{xi - xj, yi - yj, zi - zj},給定n個三元組(n <= 200000),求任意兩個三元組的差的和。

            【題目分析】
              數據范圍非常大,枚舉必然不可,需要數學方法。這個題目巧妙之處在于,模型經過了層層的包裝,要想一下子有想法還真不容易。既然不能枚舉了,這個max和min操作就不好辦了,應該設法去掉。max{a, b, c} - min{a, b, c} = |a - b| + |b - c| + | c - a| / 2,這個公式應該不難想到,但是這只是第一步,因為引進了絕對值,依然不好做。可以先算出分子,最后再除2。接下來需要一個等價變換,以a - b為例,a - b = xi - xj - yi + yj = (xi - yi) - (xj - yj),同理把b - c、c - a都寫成這種形式。這一步變換看似作用不大,但是假設我們算出所有的xi - yi之后(i = 0... n - 1),將其排序,會發現,對于第i個xi - yi,它前面的都比它小,后面的都比它大。而實際上,由于求任意兩個三元組的差,肯定xi - yi會和任意的xj - yj都作差的,加了絕對值后,它對最后的結果就會貢獻i個(xi - yi),n - i - 1個-(xi - yi)。同樣的方法算出所有的(yi - zi)和(zi - xi),結果就能夠求出來了。算法復雜度O(n * logn)。

            【題目總結】
              這是一道不錯的題目,首先考察了公式的變形,需要改寫max - min操作,之后的等價變換和排序的思想都非常值得借鑒。
            題目代碼:
            #include <cstdio>
            #include 
            <algorithm>
            using namespace std;
            const int N = 200010;

            int x[N], y[N], z[N];
            int main()
            {
                
            int n, a, b, c;

                
            while (scanf("%d"&n) == 1 && n)
                {
                    
            for (int i = 0; i < n; i++)
                    {
                        scanf(
            "%d %d %d"&a, &b, &c);
                        x[i] 
            = a - b;
                        y[i] 
            = b - c;
                        z[i] 
            = c - a;
                    }
                    sort(x, x 
            + n);
                    sort(y, y 
            + n);
                    sort(z, z 
            + n);
                    
            long long ans = 0;
                    
            for (int i = 0; i < n; i++)
                        ans 
            += (2 * i + 1 - n) * (long long)(x[i] + y[i] + z[i]);
                    printf(
            "%I64d\n", ans / 2);
                }

                
            return 0;
            }
            posted @ 2009-07-14 10:34 sdfond 閱讀(297) | 評論 (0)編輯 收藏

              題目大意是給定n個點的坐標(n <= 10000),問把這些點移動到一橫行并且一個挨著一個(具體位置任意)的最少移動步數(其中每次只能向上下左右移動一個坐標)。
              這個題目體現了轉化的思想。首先考慮這樣的問題:一個數軸上有n個坐標,問把這n個坐標移動到一個點上最少移動步數,其中每次移動一個格子。根據中位數的定義,把所有坐標排序后第n / 2個坐標是中位數,把所有坐標移動到這上面移動次數最小。證明很容易想到,因為如果不這樣的話,把目標坐標往左平移還是往右平移,勢必造成左半部的坐標集體變化1,右半部的坐標也集體變化1,如果左右半部坐標的個數不同,那么顯然就不是最優的了。
              接下來考慮題目,題目中x和y的移動是孤立的,可以分開討論。y的移動方法和上面討論的情況一樣,現在考慮x的移動。x的移動要求最終是一個挨著一個的,x排好序之后,假設最終所有點以x0為左端點依次排開,對應的點分別為x0, x1...那么問題的答案就等于把這n個坐標依次對應的挪到x0到xn-1上的步數。如果我們把這n個目標點分別都移動到x0上,那么問題就轉化成了中位數問題了。考慮把xi移動到x0上,要花費i步,為了保證問題是等價變換的,應該把xi在原坐標中對應的xi'也相應的向左移動i步,這樣xi'移動到xi的代價就是不變的。設xi'左移i步后的新位置是xi'',那么問題就轉化成:把x0''到xn-1''這n個點移動到一個坐標的最小步數,用中位數的方法就可以做出來了。
              這個題目的巧妙之處在于把一個未知問題轉化成一個已知問題。轉化的思想在數學中用的很多,應該多多練習。

            題目代碼:

            #include <cstdio>
            #include 
            <algorithm>
            using namespace std;
            const int N = 10010;

            int main()
            {
                
            int x[N], y[N], n;

                
            while (scanf("%d"&n) == 1)
                {
                    
            for (int i = 0; i < n; i++)
                        scanf(
            "%d %d"&x[i], &y[i]);
                    sort(x, x 
            + n);
                    sort(y, y 
            + n);
                    
            for (int i = 0; i < n; i++)
                        x[i] 
            -= i;
                    sort(x, x 
            + n);
                    
            int ans = 0;
                    
            for (int i = 0; i < n / 2; i++)
                        ans 
            += x[n-i-1- x[i] + y[n-1-i] - y[i];
                    printf(
            "%d\n", ans);
                }

                
            return 0;
            }
            posted @ 2009-06-25 10:13 sdfond 閱讀(258) | 評論 (0)編輯 收藏
              給定n個數求這n個數劃分成互不相交的m段的最大m子段和。
              經典的動態規劃優化的問題。設f(i, j)表示前i個數劃分成j段,且包括第i個數的最大m子段和,那么有dp方程:
                f(i, j) = max { f(i - 1, j) + v[i], max {f(k, j - 1) + v[i]}(k = j - 1 ... i - 1) }
              也就是說第i個數要么自己劃到第j段,要么和前一個數一起劃到第j段里面,轉移是O(n)的,總復雜度O(n * n * m)。
              可以引入一個輔助數組來優化轉移。設g(i, j)表示前i個數劃分成j段的最大子段和(注意第i個數未必在j段里面),那么遞推關系如下:
                g(i, j) = max{g(i - 1, j), f(i, j)},分是否加入第i個數來轉移
              這樣f的遞推關系就變成:
                f(i, j) = max{f(i - 1, j), g(i - 1, j - 1)} + v[i],轉移變成了O(1)
              這樣最后的結果就是g[n][m],通過引入輔助數組巧妙的優化了轉移。實現的時候可以用一維數組,速度很快。

            附HDU 1024題目代碼:
            #include <cstdio>
            #include 
            <algorithm>
            using namespace std;
            const int N = 1000010, INF = 0x3fffffff;

            int f[N], g[N], a[N];

            int max_sum(int m, int n)
            {
                
            int i, j, t;
                
            for (i = 1; i <= n; i++)
                {
                    t 
            = min(i, m);
                    
            for (j = 1; j <= t; j++)
                    {
                        f[j] 
            = max(f[j], g[j-1]) + a[i];
                        g[j
            -1>?= f[j-1];
                    }
                    g[j
            -1>?= f[j-1];
                }
                
            return g[m];
            }

            int main()
            {
                
            int m, n;

                
            while (scanf("%d %d"&m, &n) == 2 && m && n)
                {
                    
            for (int i = 1; i <= n; i++)
                    {
                        f[i] 
            = g[i] = -INF;
                        scanf(
            "%d"&a[i]);
                    }
                    printf(
            "%d\n", max_sum(m, n));
                }

                
            return 0;
            }
            posted @ 2009-06-19 11:18 sdfond 閱讀(4870) | 評論 (4)編輯 收藏
            僅列出標題
            共14頁: First 3 4 5 6 7 8 9 10 11 Last 
            国内精品久久久久影院薰衣草 | 久久精品一区二区影院| 亚洲午夜久久久精品影院| 久久亚洲色一区二区三区| 国产成人无码精品久久久性色| 色狠狠久久AV五月综合| 久久国产香蕉视频| 久久久久亚洲精品天堂| 久久免费国产精品| 久久久久国产精品| 99久久精品免费看国产一区二区三区 | 欧美噜噜久久久XXX| 久久久久亚洲AV无码专区桃色| 日产精品99久久久久久| 久久精品国产一区二区| 国产欧美久久久精品| 亚洲AV日韩精品久久久久| 久久久久国产一区二区| AV无码久久久久不卡网站下载| 亚洲国产成人久久综合野外| 久久久久久狠狠丁香| 精品久久久噜噜噜久久久| 精品国产乱码久久久久久呢 | 国产精品九九久久免费视频| 久久久久无码精品国产不卡| 97精品依人久久久大香线蕉97 | 久久久久久久久久久免费精品| 久久国产色AV免费观看| 亚洲国产另类久久久精品黑人| 亚洲日本va午夜中文字幕久久 | 中文字幕久久欲求不满| 99久久99这里只有免费的精品| 久久综合给合久久国产免费| 亚洲午夜精品久久久久久浪潮 | 伊人久久无码精品中文字幕| 久久久久亚洲AV无码去区首| 久久人人爽人人澡人人高潮AV| 亚洲国产成人精品91久久久| 久久久久久久免费视频| 久久婷婷五月综合成人D啪 | 久久99亚洲综合精品首页|