C++博客-英雄哪里出来-文章分类-ACM

Zju 3170 7 Levels of Binary Search Tree (BST 应用)

英雄哪里出来 — Thu, 04 Jun 2009 18:42:00 GMT

摘要: 再过几天就数据结构的考试了，看到BST那一章忍不住想做几个BST的题目，于是上次浙大月赛的题目做了一下，蛮不错的，即考察了模拟能力，又需要一些想法的目，构图是简单的，构图完成后，就有这样一个子问题需要解决：给定一颗二叉搜索树的模型（数还没有填上去），如何用... 阅读全文

英雄哪里出来 2009-06-05 02:42 发表评论

Pku 3140 Contestants Division (无向图割边+树形DP)

英雄哪里出来 — Thu, 07 May 2009 05:35:00 GMT

摘要: 由于该图不是一颗树，所以首先要将一些块压缩成点，所谓块就是没有割点的分量，于是只要求出割边，然后删除，之后对整个图进行Floodfill，得到的连通分量再用割边补图，得到的图一定是一棵树，然后就可以树形DP了。#include #define MAXN 100010using namespace std;struct... 阅读全文

英雄哪里出来 2009-05-07 13:35 发表评论

Pku 2777 Count Colors(线段树)

英雄哪里出来 — Tue, 07 Apr 2009 13:10:00 GMT

摘要: /**//*还是一个染色的覆盖问题，修改一个区段的颜色，查询一个区段有多少不同的颜色。一开始用最原始的做法，修改，查询，TLE了，然后去上体育课，突然就想到一个优化，由于颜色只有30种，所以可以把各种颜色的状态压缩到一个整数中，这样统计时就不用hash了快了不少，哈哈！于是该线段树共有两个域，一个cover域，表明该区间下的颜色是单一的还是混合的，还有一个计数域tree，该值表明该区间颜色的状态。... 阅读全文

英雄哪里出来 2009-04-07 21:10 发表评论

Pku 3468 A Simple Problem With Integers(线段树)

英雄哪里出来 — Tue, 07 Apr 2009 08:31:00 GMT

/*

很早以前着手的题，采用了和Pku 2528 的做法做，可惜一直超时，原因是这题如果覆盖次数一多，
可能最后真正被完全覆盖的区间可能就没了，是的查询的时候全部结点都需要遍历，使得
原来O(log(n))可以解决的问题退化为O(n)，金工实习和匡剑兄一起，于是决定请教一下他，经过匡剑兄的指点，
终于明白了，一共维护两个域，一个是当前结点的增量值，另外一个是以该结点为根的总和，（注：
祖先的分数不算在内）
那么一共两个操作：插入和询问可以这样：
插入：到达尾部结点时将增量加在该结点上，并且把该区间总增量返还给它父亲，一直到根
询问：一路走下去，并且将父亲的增量按权值分配给它的儿子，最后回溯。如此一来，插入和询问都是O(log(n))
*/
#include <iostream>

using namespace std;

__int64 tree[2000010];
__int64 inc[2000010];
bool flag[2000010];

__int64 a[100010];
int n, m;
int i;

__int64 Build(int p, int l, int r) {
    if(l == r) {
        tree[p] = a[l];
        return tree[p];
    }
    int mid = (l + r) / 2;
    tree[2*p] = Build(2*p, l, mid);
    tree[2*p+1] = Build(2*p+1, mid+1, r);
    return tree[2*p] + tree[2*p+1];
}

__int64 Query(int p, int s, int e, int l, int r) {
    int mid = (l + r) / 2;
    __int64 temp = 0;

    if(s == l && e == r) {
        return tree[p];
    }

    temp = (__int64)(e-s+1)*inc[p];

    if(e <= mid) {
        return Query(2*p, s, e, l, mid) + temp;
    }else if(mid + 1 <= s) {
        return Query(2*p+1, s, e, mid+1, r) + temp;
    }else {
        return Query(2*p, s, mid, l, mid) + Query(2*p+1, mid+1, e, mid+1, r) + temp;
    }
}

__int64 Insert(int p, int s, int e, int l, int r, __int64 value) {

    if(s == l && e == r) {
        inc[p] += value;
        tree[p] += value * (r - l + 1);
        return value * (r - l + 1);
    }

    int mid = (l + r) / 2;
    __int64 buf = 0;

    if(e <= mid) {
        buf += Insert(2*p, s, e, l, mid, value);
    }else if(mid + 1 <= s) {
        buf += Insert(2*p+1, s, e, mid+1, r, value);
    }else {
        buf += Insert(2*p, s, mid, l, mid, value);
        buf += Insert(2*p+1, mid+1, e, mid+1, r, value);
    }
    tree[p] += buf;
    return buf;
}

int main() {

    int i, x, y;
    __int64 z;
    char str[5];
    while(scanf("%d %d", &n, &m) != EOF) {
        for(i = 1; i <= n; i++) {
            scanf("%I64d", &a[i]);
        }
        tree[1] = Build(1, 1, n);
        memset(inc, 0, sizeof(inc));
        while(m --) {
            scanf("%s", str);
            if(str[0] == 'Q') {
                scanf("%d %d", &x, &y);
                printf("%I64d\n", Query(1, x, y, 1, n) );
            }else {
                scanf("%d %d %I64d", &x, &y, &z);
                tree[1] = Insert(1, x, y, 1, n, z);
            }
        }
    }
    return 0;
}

英雄哪里出来 2009-04-07 16:31 发表评论

Pku 3368 Frequent Values (线段树)

英雄哪里出来 — Tue, 07 Apr 2009 05:42:00 GMT

摘要: /**//*上金工实习，无聊，找到题目想想吧，那就pku 3368吧，一直想做掉却一直没想法，题目意思很明确，给定一串序列，然后是m条询问，问[a, b]区间之间出现的数字频率最多的是哪个数，由于m很大，所以询问的复杂度必须要是log(n)，这样一来就先确定下来是线段树了，但是以前没深入想下去，重新看了遍题目，然后到了8教就开始想，突然就有思路了，主要是以前有个... 阅读全文

英雄哪里出来 2009-04-07 13:42 发表评论

hust 1017 Exact Cover (Dancing Links)

英雄哪里出来 — Sat, 04 Apr 2009 04:14:00 GMT

摘要: /**//*从昨天下午就开始搞，今天中午才搞定，Dancing Links 果然高深神奇的双向环形十字链表······转的头晕了-_-||不过蛮有成就感的^v^记录一下解题过程，先反反复复看了一遍Donald E.Knuth的论文，就开始攻hust 1017这道题目，题目意思很明确：给定一个由0和1... 阅读全文

英雄哪里出来 2009-04-04 12:14 发表评论

HDU 1560 DNA sequence (IDA*)

英雄哪里出来 — Thu, 12 Mar 2009 07:22:00 GMT

问题描述：
构造一个串，使得它包含所有的给定DNA序列，并且要求长度最短。

采用dfs策略，对于每个串定义1个指针，当全部指针为串尾时判断构造的长度，由于状态空间过大，但是又存在冗余搜索，可以用迭代加深将状态减少。最长待构造长度 + 当前长度 < 迭代的最大深度则直接return，大大减少了状态数。

代码如下：

#include <iostream>
using namespace std;

struct point {
    int poi[8];
}temp;

char map[9][7];
int len[9];
int Min;
char DNA[] = {'A', 'C', 'G', 'T'};
int n;

int dfs(point tp, int sum, int depth) {
    int i, j;
    point temp;

    if(sum > depth)
        return 0;

    for(i = 0; i < n; i++) {
        if( len[i] - tp.poi[i] + sum > depth)
            return 0;
    }

    for(i = 0; i < n; i++) {
        if(map[i][ tp.poi[i] ])
            break;
    }

    if(i == n) {
        return 1;
    }

    int flag;
    for(i = 0; i < 4; i++) {
        flag = 0;
        for(j = 0; j < n; j++) {

            if(map[j][ tp.poi[j] ] == DNA[i]) {
                flag = 1;
                temp.poi[j] = tp.poi[j] + 1;
            }else
                temp.poi[j] = tp.poi[j];
        }
        if(flag)
            if ( dfs(temp, sum + 1, depth) )
                return 1;
    }

    return 0;
}

int main() {
    int t, i;
    scanf("%d", &t);
    while(t--) {
        scanf("%d", &n);
        for(i = 0; i < n; i++) {
            scanf("%s", map[i]);
            len[i] = strlen(map[i]);
        }
        for(i = 0; i < n; i++) {
            temp.poi[i] = 0;
        }

        for(i = 1; ; i++) {
            if( dfs(temp, 0, i) )
                break;
        }

        printf("%d\n", i);
    }
    return 0;
}

英雄哪里出来 2009-03-12 15:22 发表评论

Pku 1383 Labyrinth && Zju 3172 Extend 7-day Vacation (最长路)

英雄哪里出来 — Tue, 10 Mar 2009 15:48:00 GMT

摘要: 求任意图的最长路。其实思路很简单，两次bfs即可。首先在图中任意选择一个点，对它进行bfs扩展，找到距该点最远的点，然后再一次bfs寻找最远点，此时找到的最远距离就是最长路的大小。Pku 1383 Labyrinth 代码： #include #include using namespace s... 阅读全文

英雄哪里出来 2009-03-10 23:48 发表评论

Hdu 2363 Cycling(最短路)

英雄哪里出来 — Tue, 10 Mar 2009 01:14:00 GMT

摘要: 每个点有一个高度，从1到n使得最大高度和最小高度的差值最小，如果有相同高度，取路径最短的。以前比赛的时候没有去看，以为是很难的题，后来听说要用二分，一直拖着，今天早上起来，读了一下题目发现根本不用二分，点只有100个，可以对每个点的高度进行上下界枚举求最短路保存最优值。这样的话最坏复杂度是O(n^4)，这里n == 100，而且测试样例有100组，但是这个题目的限制条件决定了有很多地方可以剪枝。首... 阅读全文

英雄哪里出来 2009-03-10 09:14 发表评论

Pku 3346 Treasure of the Chimp Island (Bfs)

英雄哪里出来 — Tue, 10 Mar 2009 00:20:00 GMT

摘要: 去年做杭州网赛的时候遇到的题目，当时一点思路都没有，过后一直没去做，今天看了一下，发现其实和hdu的1044很像，可以先缩图，然后bfs，我用了两次bfs实现。具体思路是对于每一个非墙非走廊的点进行bfs，扩展和它相邻的非墙非走廊的点，保存到邻接表中，然后对于所有边界上是gate的点进行bfs，用优先队列实现，状态为三维，即坐标+内力，其实可以将每个点离散化到一个数字，以减少内存开销来换取时间。代... 阅读全文

英雄哪里出来 2009-03-10 08:20 发表评论

Pku 2662 A Walk Through the Forest && HDU 1428 漫步校园 (bfs + dfs)

英雄哪里出来 — Mon, 09 Mar 2009 11:12:00 GMT

首先从终点bfs，保存每一个节点到终点的最短路径，然后从起点dfs，记忆化，如果满足题目给定的拓扑序就加上从那个点到终点的路径数。所谓满足拓扑序就是题目所给定的taking a path from A to B to be progress if there exists a route from B to his home that is shorter than any possible route from A，这句话仔细读上几十遍就能明白题目意图了。

漫步校园
代码：

#include <iostream>
#include <queue>
using namespace std;

int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
struct point {
    int x;
    int y;
    int time;

    bool friend operator < (point a, point b) {
        return a.time > b.time;
    }

}temp, tt;

priority_queue < point > q;
int hash[51][51], map[51][51];
__int64 dp[51][51];
int n;

__int64 dfs(int x, int y) {

    int i;
    int tx, ty;
    __int64 sum = 0;

    if(x == n && y == n)
        return 1;

    for(i = 0; i < 4; i++) {
        tx = x + dir[i][0];
        ty = y + dir[i][1];
        if(tx < 1 || ty < 1 || tx > n || ty > n)
            continue;
        if(hash[x][y] > hash[tx][ty]) {
            if(dp[tx][ty] == -1) {
                dp[tx][ty] = dfs(tx, ty);
            }
            sum += dp[tx][ty];
        }
    }

    return sum;
}
int main() {
    int i, j;
    while(scanf("%d", &n) != EOF) {

        for(i = 1; i <= n; i++) {
            for(j = 1; j <= n; j++) {
                scanf("%d", &map[i][j]);
            }
        }
        temp.x = n;
        temp.y = n;
        temp.time = map[n][n];
        memset(hash, -1, sizeof(hash));
        hash[n][n] = map[n][n];
        while(!q.empty())
            q.pop();

        q.push( temp );

        while(!q.empty()) {
            temp = q.top();
            q.pop();
            for(i = 0; i < 4; i++) {
                tt.x = temp.x + dir[i][0];
                tt.y = temp.y + dir[i][1];
                if(tt.x < 1 || tt.y < 1 || tt.x > n || tt.y > n)
                    continue;
                tt.time = temp.time + map[tt.x][tt.y];

                if(hash[ tt.x ][ tt.y ] == -1 || tt.time < hash[ tt.x ][ tt.y ]) {
                    hash[ tt.x ][ tt.y ] = tt.time;
                    q.push( tt );
                }
            }
        }

        memset(dp, -1, sizeof(dp));

        dp[1][1] = dfs(1, 1);
        printf("%I64d\n", dp[1][1]);
    }
    return 0;
}

英雄哪里出来 2009-03-09 19:12 发表评论

Pku 1599 Station Balance (DFS)

英雄哪里出来 — Tue, 03 Mar 2009 02:37:00 GMT

摘要: 解题思路：枚举所有物品的子集，然后再枚举子集的组合，数据量很小，不需要剪枝。 #include #include using namespace std;struct Stack { int a[100]; &nb... 阅读全文

英雄哪里出来 2009-03-03 10:37 发表评论

HDOJ 1625 Numbering Paths (DP)

英雄哪里出来 — Mon, 02 Mar 2009 10:39:00 GMT

问题描述：
给定一张有向图邻接表，求任意点对间的路径数。

解题思路：
首先floyed一遍，确定任意点对间是否可达，然后枚举点对进行记忆化搜索。具体思路就是如果i到k有边，k能够到达j，那么k到达j的路径数必定是i到j路径数的子集。枚举所有和i邻接的k即可。但是这道题目有可能有环，题目要求有环认为无穷路径，这样处理起来也是很方便的，可以这样想，如果i到k有边，但是k到j没有路径，那么即使k点存在一个环也对i到j的路径数没有任何影响，但是如果k有环，而且k可以到达j，那么i到j就必定有无穷多条路径了（因为可以在到达k的时候绕着环走啊走......），之后求出所有点对间的路径即可。

代码如下：

#include <iostream>
#include <vector>
using namespace std;

int map[101][101];
vector < int > vec[101];
int n;
int dp[101][101];

int dfs(int start, int end) {

    int i, size = vec[start].size();
    int sum = 0;

    if(!map[start][end] && start != end)
        return 0;

    if(map[start][end] && map[end][start])
        return -2;

    if(start == end)
        return 1;

    for(i = 0; i < size; i++) {
        int u = vec[start][i];

        if(map[u][start] && map[start][u])
            return -2;

        if(dp[u][end] == -1)
            dp[u][end] = dfs(u, end);

        if(dp[u][end] == -2)
            return -2;

        sum += dp[u][end];
    }
    return sum;
}

int main(){
    int m, i, j, k, x, y;
    int cas = 0;

    while(scanf("%d", &m) != EOF) {
        memset(map, 0, sizeof(map));
        for(i = 0; i < 101; i++)
            vec[i].clear();
        n = 0;
        while(m--) {
            scanf("%d %d", &x, &y);
            map[x][y] = 1;
            vec[x].push_back( y );
            if(x > n) n = x;
            if(y > n) n = y;
        }

        for(k = 0; k <= n; k++) {
            for(i = 0; i <= n; i++) {
                for(j = 0; j <= n; j++) {

                    if(map[i][k] && map[k][j])
                        map[i][j] = 1;
                }
            }
        }

        memset(dp, -1, sizeof(dp));
        for(i = 0; i <= n; i++) {
            for(j = 0; j <= n; j++) {

                if(dp[i][j] == -1)
                    dp[i][j] = dfs(i, j);
            }
        }

        printf("matrix for city %d\n", cas++);

        for(i = 0; i <= n; i++) {
            for(j = 0; j <= n; j++) {

                if(i == j) {
                    if(dp[i][j] == -2)
                        printf(" -1");
                    else
                        printf(" 0");
                }else {
                    if(dp[i][j] == -2)
                        printf(" -1");
                    else
                        printf(" %d", dp[i][j]);
                }
            }
            puts("");
        }

    }
    return 0;
}

英雄哪里出来 2009-03-02 18:39 发表评论

Pku 1485 Fast food(DP)

英雄哪里出来 — Fri, 20 Feb 2009 15:07:00 GMT

摘要: 问题描述：给定n个点在直线上的距离，然后让你选择其中的p个点建立饭店，要求其他点都选择一家离自己最近的饭店供应，求总路程最短。解题思路：这道题目沉积很久了，去年就看到，但是一直不敢做，主要还是因为是DP，有点怕，寒假有一天拿过来做了一下，发现其实不是很难，于是开始推状态转移，当时的思路用是dp[i][j]表示第i个饭店建在第j个位置的最优解，想想没错，于是开始状态转移，中途需要一些辅助数组，dis... 阅读全文

英雄哪里出来 2009-02-20 23:07 发表评论

Pku 3134 Power Calculus (BFS)

英雄哪里出来 — Mon, 16 Feb 2009 12:59:00 GMT

问题描述：
给定初始的x，可以通过乘法将其变为x^2，再变为x^4，x^8，x^16，x^32，也可以用除法，x^31 = x^32 / x，但是操作数必须是已经计算出来的数，给定一个指数，要求得到这个指数的最小步数。比如31输出6（1 2 4 8 16 32 31）。

这道题目是去年参加whu邀请赛的时候遇到的，当时是热身赛题目，后来一直没想通，看了威士忌的解题报告，是用迭代加深写的，后来想了想越看越象BFS，就开始敲了，可是973这组数据总是输出13，搞了半天把路径输出来发现了弊病所在，就是在两个搜到相同的值的步数是一样的时候，不能略过，因为路径不同可能导致最后的结果不同，但是记录路径再比较就太冗繁了，我的策略是将步数相同的值多搜几次取最优，竟然过了，344MS。不过时限开了5000MS，怎么搜都可以过的。

具体思路：
对一个结构体进行Bfs，记录路径，每次搜到u这个数的当前步数小于先前搜出的数则入队，如果等于，也入队，并且u这个数的计数器+1，直到达到某个limit则不再搜（后来刷了下，limit取6的时候可以达到74MS）保存最优值即可。

代码如下：

#include <iostream>
#include <queue>
using namespace std;

struct point
{
    int stack[30];
    int x;
    int top;
    int step;
}temp, tt, buf;

int n;
int Min[2001];
int coun[2001];

queue < point > q;

int main()
{
    int i, j, k;
    memset(Min, -1, sizeof(Min) );
    memset(coun, 0, sizeof(coun));
    Min[1] = 0;

    temp.top = 0;
    temp.stack[ temp.top++ ] = 1;
    temp.step = 0;
    temp.x = 1;

    q.push( temp );

    while(!q.empty())
    {
        temp = q.front();
        q.pop();

        for(i = 0; i < temp.top; i++){
            for(j = -1; j <= 1; j += 2)
            {
                tt = temp;
                tt.step = temp.step + 1;
                int u = tt.x + tt.stack[i] * j;

                if(u <= 1 || u > 2000)
                    continue;

                if(tt.step == Min[u])
                {
                    coun[u] ++;
                    if(coun[u] > 10)
                        continue;

                    tt.stack[ tt.top ++ ] = u;
                    tt.x = u;
                    q.push( tt );
                }

                if(Min[u] == -1 || tt.step < Min[u])
                {
                    Min[u] = tt.step;
                    tt.stack[ tt.top ++ ] = u;
                    tt.x = u;
                    q.push( tt );
                }
            }
        }
    }

    while( scanf("%d", &n) != EOF && n ){
        printf("%d\n", Min[n] );
    }
    return 0;
}

英雄哪里出来 2009-02-16 20:59 发表评论

Pku 1632 Vase Collection (Dfs)

英雄哪里出来 — Sun, 15 Feb 2009 13:15:00 GMT

摘要: 问题描述：给定一些关系，是个二分图，要求它的最大完美匹配。解题思路：枚举左边的点，对任意一个点枚举它的边子集，再在枚举到的边子集的右边点集中以相同方式枚举，最后形成左右两边均为K的点，检测是否为完全二分图即可。代码如下： #include #include using namespace std;... 阅读全文

英雄哪里出来 2009-02-15 21:15 发表评论

Pku 1651 Multiplication Puzzle(DP)

英雄哪里出来 — Sun, 15 Feb 2009 11:49:00 GMT

问题描述：
给定一排数，从中按顺序取出n-2个数，并且每取一次就把该数和相邻的数相乘，然后所有的n-2个乘积相加，要求和最小。
解题思路：
考虑区间[start, end], 如果在其中取出第j个数(start+1 <= j <= end - 1)，那么在这之前j左边的和右边的数必然是分开的两个子问题，没有相交，于是可以得到最优子结构的性质。由于是区间，可以采用记忆化搜索。
dp[i][j] = min{dp[i][k] + dp[k][j] + a[i]*a[k]*a[j], i+1 <= k <= j-1}
代码如下：

#include <iostream>

using namespace std;

int dp[101][101];
int num[101];
int n;

int dfs(int s, int e)
{
    if(e - s < 2)
        return 0;
    int i;
    int Min = 1000000001;
    for(i = s + 1; i <= e - 1; i++)
    {
        if(dp[s][i] == -1)
            dp[s][i] = dfs(s, i);

        if(dp[i][e] == -1)
            dp[i][e] = dfs(i, e);

        if(dp[s][i] + dp[i][e] + num[s] * num[i] * num[e] < Min){
            Min = dp[s][i] + dp[i][e] + num[s] * num[i] * num[e];
        }
    }
    return Min;
}

int main()
{
    int i;
    while(scanf("%d", &n) != EOF)
    {
        memset(dp, -1, sizeof(dp));

        for(i = 1; i <= n; i++){
            scanf("%d", &num[i]);
        }
        printf("%d\n", dfs(1, n));
    }
}

英雄哪里出来 2009-02-15 19:49 发表评论

Pku 3209 From Pythagoras to …(数论)

英雄哪里出来 — Tue, 10 Feb 2009 13:04:00 GMT

摘要: 问题描述：给定一个数，问它是否能够表示成两个整数的平方和。解题思路：费马平方和定理的表述是：奇素数能表示为两个平方数之和的充分必要条件是该素数被4除余1。于是一个素数p = 4n+1或者p = 2则必定能表示成两个平方数之和。同样可以推导出如果两个数均能表示成两个平方数之和，则他们的乘积必定能表示成两个平方数之和：p = a^2 + b^2;q = c^2 + d^2;p*q = (a^2 + b... 阅读全文

英雄哪里出来 2009-02-10 21:04 发表评论

Pku 3361 Gaussian Prime Factors (数论)

英雄哪里出来 — Tue, 10 Feb 2009 12:05:00 GMT

摘要: 问题描述：求一个整数的高斯素因子。解题思路：高斯整数a + bi是素数当且仅当：1)a、b中有一个是零，另一个数的绝对值是形如4n + 3的素数；2)a、b均不为零，而a2 + b2为素数；于是只要将每个分解素因子，对于每个素因子P,如果该素因子形如4n+3，则必定能分解成(a+bj)(a-bj) = a^2 + b^2，枚举解决。代码如下： #include 阅读全文

英雄哪里出来 2009-02-10 20:05 发表评论

Pku 1157 LITTLE SHOP OF FLOWERS (DP)

英雄哪里出来 — Mon, 09 Feb 2009 07:32:00 GMT

问题描述：
给出一个矩阵，要求取数，每一行取一个，并且满足下一行取的数的列数要大于前一行取的列数，使得最后总和最大。

		V A S E S
		1	2	3	4	5
Bunches	1 (azaleas)	7	23	-5	-24	16
	2 (begonias)	5	21	-4	10	23
	3 (carnations)	-21	5	-4	-20	20

如上表，则取23 + 10 + 20 = 53
解题思路：
该题满足最优子结构，于是有DP解法。
首先定义：
map[i][j] 表示第i行第j列的值
dp[i][j] 表示到第i行为止取map[i][j]时的最优解
则有状态转移方程：dp[i][j] = max{dp[i-1][k] + map[i][j], 1 <= k < j}

代码如下：

#include <iostream>

using namespace std;

int map[101][101];
int dp[101][101];
int f, v;

int main()
{
    int i, j, k;

    while(scanf("%d %d", &f, &v) != EOF)
    {
        int Max = -1000000;
        for(i = 1; i <= f; i++)
        {
            for(j = 1; j <= v; j++)
            {
                scanf("%d", &map[i][j]);
            }
        }

        for(i = 0; i <= f; i++)
            for(j = 0; j <= f; j++)
                dp[i][j] = -10000000;

        for(i = 1; i <= v; i++)
            dp[1][i] = map[1][i];

        for(i = 2; i <= f; i++)
        {
            for(j = i; j <= v; j++)
            {
                dp[i][j] = -10000000;
                for(k = 1; k < j; k++)
                {
                    if(map[i][j] + dp[i-1][k] > dp[i][j])
                        dp[i][j] = map[i][j] + dp[i-1][k];
                }
            }
        }

        for(i = 1; i <= v; i++)
        {
            if(dp[f][i] > Max)
                Max = dp[f][i];
        }

        printf("%d\n", Max);
    }
}

英雄哪里出来 2009-02-09 15:32 发表评论

Pku 1080 Human Gene Functions (DP)

英雄哪里出来 — Mon, 09 Feb 2009 06:30:00 GMT

问题描述：
给出两个串，对应字母有权值，可以错位安排，使得最后总权和最大。
解题思路：
首先定义:
rt[a][b]   表示字符a和字符b配对时的权值
dp[i][j] 表示第一个串到i和第二个串到j两个子串所组合出的最大权和为dp[i][j];
1)如果第i个字符和第j个字符配对，那么dp[i][j] = dp[i-1][j-1] + rt[str1[i]][str2[j]];
2)如果第一个串的第i个字符和'-'配对, 那么dp[i][j] = dp[i-1][j] + rt[str1[i]]['-'];
3)如果第二个串的第j个字符和'-'配对,那么dp[i][j] = dp[i][j-1] + rt['-'][str2[j]];
于是dp[i][j] = max{ dp[i-1][j-1] + rt[str1[i]][str2[j]],   dp[i-1][j] + rt[str1[i]]['-'], dp[i][j-1] + rt['-'][str2[j]] };

核心代码：

#include <iostream>

using namespace std;

int dp[110][110];
char str[2][110];
int len[2];
int i, j;

int rt[5][5] = {
    {5, -1, -2, -1, -3},
    {-1, 5, -3, -2, -4},
    {-2, -3, 5, -2, -2},
    {-1, -2, -2, 5, -1},
    {-3, -4, -2, -1, 0}
};

int num(char c){
    if(c == 'A')
        return 0;
    if(c == 'C')
        return 1;
    if(c == 'G')
        return 2;
    if(c == 'T')
        return 3;
    return 4;
}

int Max(int a, int b, int c){
    if(c > b) b = c;
    return a > b ? a : b;
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--){
        for(i = 0; i < 2; i++){
            scanf("%d", &len[i]);
            scanf("%s", &str[i][1]);
        }

        dp[0][0] = 0;
        for(i = 1; i <= len[0]; i++){
            dp[i][0] = dp[i-1][0] + rt[ num(str[0][i]) ][num('-')];
        }

        for(i = 1; i <= len[1]; i++){
            dp[0][i] = dp[0][i-1] + rt[ num('-') ][ num(str[1][i]) ];
        }

        for(i = 1; i <= len[0]; i++){
            for(j = 1; j <= len[1]; j++){
                dp[i][j] = Max(
                    dp[i-1][j-1] + rt[ num(str[0][i]) ][num(str[1][j])],
                    dp[i-1][j] + rt[ num(str[0][i]) ][ num('-') ],
                    dp[i][j-1] + rt[ num('-') ][ num(str[1][j]) ]
                    );
            }
        }
        printf("%d\n", dp[ len[0] ][ len[1] ]);
    }
}

英雄哪里出来 2009-02-09 14:30 发表评论

Pku 2958 Pizza delivery (DP)

英雄哪里出来 — Sun, 08 Feb 2009 14:43:00 GMT

问题描述：
要求求一个点(r, c)使得它到达(i, j)的曼哈顿距离与该点权值乘积总和最小，其中(1 <= i <= n, 1 <= j <= m)
(1 <= n, m <= 100) 因此，暴力的复杂度是O(n^4)，显然是TLE的，想了一下，想到一个O(n^3)的算法，算法核心还是DP。
解题思路：
首先定义:
map[i][j]       表示原图(i, j)这个点的权值
sum[i][j]       表示第1行一直到第i行中所有第j列的权值总和
rt[i][j]           表示以该点为(r, c)而得到的权值总和
答案就是 Min = min{rt[i][j] , (1 <= i <= n, 1 <= j <= m) }

首先预处理sum[i][j] ，然后每次暴力计算rt[i][1]的值，由于rt[i][j-1] 和rt[i][j]相邻，于是他们相对于别的点曼哈顿距离必定均相差1，每次计算rt[i][j]只要枚举列k，如果第k列在j-1以及其左边那么rt[i][j] 比rt[i][j-1]大sum[n][k]，否则要小sum[n][k]，于是问题就解决了，每次统计rt[i][j]然后取最小值即可。

核心代码：
   if(k <= j-1)
         rt[i][j] += sum[n][k];
   else
         rt[i][j] -= sum[n][k];

#include <iostream>

using namespace std;

int n, m, i, j, k;
int Min;
int map[101][101];
int sum[101][101];
int rt[101][101];

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        Min = -1;
        scanf("%d %d", &m, &n);

        for(i = 1; i <= n; i++)
        {
            for(j = 1; j <= m; j++)
            {
                scanf("%d", &map[i][j]);
            }
        }

        for(i = 1; i <= n; i++)
        {
            for(j = 1; j <= m; j++)
                sum[i][j] = sum[i-1][j] + map[i][j];
        }

        for(i = 1; i <= n; i++)
        {
            rt[i][1] = 0;

            //计算(i, 1) 这个点作为Ketichen的距离和
            for(j = 1; j <= n; j++)
            {
                for(k = 1; k <= m; k++)
                {
                    rt[i][1] += ( abs(i-j) + abs(k-1) ) * map[j][k];
                }
            }

            if(Min == -1 || rt[i][1] < Min)
                Min = rt[i][1];

            //根据(i, j-1)计算(i, j)的值
            for(j = 2; j <= m; j++)
            {
                rt[i][j] = rt[i][j-1];

                for(k = 1; k <= m; k++)
                {
                    if(k <= j-1)
                        rt[i][j] += sum[n][k];
                    else
                        rt[i][j] -= sum[n][k];
                }
                if(Min == -1 || rt[i][j] < Min)
                    Min = rt[i][j];
            }
        }

        printf("%d blocks\n", Min);
    }
}

英雄哪里出来 2009-02-08 22:43 发表评论