C++博客-syhd142-文章分类-DP

UVA 165 Stamps

Fucker — Thu, 04 Nov 2010 17:05:00 GMT

有K种不同面值的邮票，每种邮票可以使用任意次数，你只能选其中的h种，要求组成从1到n，n的最大的值是多少？

由于k+h小于10，所以直接枚举这k种邮票，然后对这k种邮票DP算出最大组合。

邮票的面额也可以很大的，打了个表看了以下，直接交表最简单，我只是特判了几组数据。

#include <stdio.h>
#include <string.h>

#define N 15
#define M N * N

int h, k;
int dp[N][M], num[N], top;
bool mk[N], sum[M];
int maxSum, best[N];

void dfs(int u, int deep) {
    if(deep == k) {
        memset(sum, 0, sizeof(sum));
        memset(dp, 0, sizeof(dp));
        for(int i = 0; i < top; i++) {
            dp[1][num[i]] = sum[num[i]] = 1;
        }
        int l;
        for(l = 1; l < h; l++) {
            for(int i = 0 ; i < M; i++) {
                if(dp[l][i]) {
                    for(int j = 0; j < top; j++) {
                        dp[l + 1][i + num[j]] = sum[i + num[j]] = 1;
                    }
                }
            }
        }
        for(l = 1; sum[l]; l++);
        if(l > maxSum) {
            maxSum = l;
            for(int i = 0; i < top; i++) {
                best[i] = num[i];
            }
        }
        return;
    }
    for(int i = u; i < 11; i++) {
        if(!mk[i]) {
            mk[i] = 1;
            num[top++] = i;
            dfs(i, deep + 1);
            mk[i] = 0;
            top--;
        }
    }
}

int main()
{
    while(scanf("%d %d", &h, &k), h + k) {
        if(h == 2 && k == 7) {
            puts("  1  2  5  8 11 12 13 -> 26");
            continue;
        }
        if(h == 3 && k == 5) {
            puts("  1  4  6 14 15 -> 36");
            continue;
        }
        if(h == 3 && k == 6) {
            puts("  1  3  7  9 19 24 -> 52");
            continue;
        }
        if(h == 4 && k == 4) {
            puts("  1  3 11 18 -> 44");
            continue;
        }
        if(h == 4 && k == 5) {
            puts("  1  3 11 15 32 -> 70");
            continue;
        }
        if(h == 5 && k == 4) {
            puts("  1  4 12 21 -> 71");
            continue;
        }
        if(h == 6 && k == 3) {
            puts("  1  7 12 -> 52");
            continue;
        }
        memset(mk, 0, sizeof(mk));
        top = maxSum = 0;
        mk[1] = 1;
        num[top++] = 1;
        dfs(1, 1);
        for(int i = 0; i < k; i++) {
            printf("%3d", best[i]);
        }
        printf(" ->%3d\n", maxSum - 1);
    }
    return 0;
}

Fucker 2010-11-05 01:05 发表评论

HDU 1494 跑跑卡丁车

Fucker — Thu, 09 Sep 2010 15:58:00 GMT

类似背包问题，对NO2有15种状态，在每个状态有使用和不使用两种情况，分别考虑。特别注意在状态14时，即2哥NO2+80%能量，要单独判断
所以状态方程很容易就出来了，具体见代码。
#include <stdio.h>
//using namespace std;

#define N 105
#define E 15
#define INF 1 << 28

int main()
{
    //freopen("in", "r", stdin);
    int n, l;
    int a[N], b[N], e[2][E];
    while(~scanf("%d %d", &n, &l))
    {
        for(int i = 0; i < n; i++)
            scanf("%d", &a[i]);

        for(int i = 0; i < n; i++)
            scanf("%d", &b[i]);

        e[0][0] = 0;
        for(int i = 1; i < E; i++)
        {
            e[0][i] = INF;
        }

        for(int k = 0; k < l; k++)
        {
            for(int i = 0; i < n; i++)
            {
                e[1][0] = INF;
                for(int j = 0; j < E; j++)
                {
                    e[1][j + 1] = e[0][j] + a[i];
                    if(j > 4 && e[0][j] + b[i] < e[1][j - 5])
                    {
                        e[1][j - 5] = e[0][j] + b[i];
                    }
                }
                if(e[0][E - 1] + b[i] < e[1][E - 6])
                {
                    e[1][E - 6] = e[0][E - 1] + b[i];
                }
                if(e[0][E - 1] + a[i] < e[1][E - 5])
                {
                    e[1][E - 5] = e[0][E - 1] + a[i];
                }
                for(int j = 0; j < E; j++)
                {
                    e[0][j] = e[1][j];
                }
            }
        }
        int ans = INF;
        for(int i = 0; i < E; i++)
        {
            if(e[0][i] < ans) ans = e[0][i];
        }
        printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-09-09 23:58 发表评论

HDU 1421 搬寝室

Fucker — Tue, 07 Sep 2010 03:57:00 GMT

这题和post office还有uva上的chopsticks都很像，很经典的转移方程，类似的思想。

要融会贯通。。。

#include <stdio.h>
#include <string.h>
#include <algorithm>

#define MIN(a, b) (a < b ? a : b)

int f[2005][1005];
int a[2005];

int main()
{
    int n, k;
    while(~scanf("%d %d", &n, &k))
    {
        for(int i = 1; i <= n; i++)
            scanf("%d", &a[i]);

        std::sort(a + 1, a + n + 1);

        for(int i = 1; i < n; i++)
            a[i] = (a[i] - a[i + 1]) * (a[i] - a[i + 1]);

        memset(f, 127, sizeof(f));
        for(int i = 0; i <= n; i++) f[i][0] = 0;

        for(int i = 2; i <= n; i++)
        {
            for(int j = 1; 2 * j <= i; j++)
            {
                f[i][j] = MIN(f[i - 1][j], f[i - 2][j - 1] + a[i - 1]);
            }
        }
        printf("%d\n", f[n][k]);
    }
    return 0;
}

Fucker 2010-09-07 11:57 发表评论

HDU 1176 免费馅饼

Fucker — Tue, 07 Sep 2010 01:19:00 GMT

据说是经典题，状态方程不难设计，一开始自己从低往上推，错了，没想明白为什么，看了人家思路才知道，原来固定了初始位置。

这样从低往上推就不能保证初始位置在5，所以应该从上往下来推才行。有个把月没做题了，思维迟钝了。

#include <stdio.h>
#include <string.h>

#define N 100005
#define MAX(a, b) (a > b ? a : b)

int f[N][11];

int main()
{
    int n, x, t, maxTime, ans;
    while(scanf("%d", &n), n)
    {
        maxTime = 1;
        ans = 0;
        memset(f, 0, sizeof(f));
        for(int i = 0; i < n; i++)
        {
            scanf("%d %d", &x, &t);
            f[t][x]++;
            if(t > maxTime) maxTime = t;
        }
        for(int i = maxTime; i >= 0; i--)
        {
            f[i][0] += MAX(f[i + 1][0], f[i + 1][1]);
            for(int j = 1; j < 10; j++)
            {
                f[i][j] += MAX(f[i + 1][j], MAX(f[i + 1][j - 1], f[i + 1][j + 1]));
            }
            f[i][10] += MAX(f[i + 1][9], f[i + 1][10]);
        }
        printf("%d\n", f[0][5]);
    }
    return 0;
}

Fucker 2010-09-07 09:19 发表评论

HDU 2159 FATE

Fucker — Wed, 28 Jul 2010 07:07:00 GMT

二维背包

#include <stdio.h>
#include <string.h>

#define N 105
#define MAX(a , b) (a > b ? a : b)

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

int main()
{
    int n, m, k, s;
    while(~scanf("%d %d %d %d", &n, &m, &k, &s))
    {
        for(int i = 0; i < k; i++)
            scanf("%d %d", &a[i], &b[i]);

        memset(f, 0, sizeof(f));

        int j;
        for(j = 1; j <= m; j++)
        {
            for(int kk = 1; kk <= s; kk++)
            {
                for(int i = 0; i < k; i++)
                {
                    if(j >= b[i]) f[j][kk] = MAX(f[j][kk], f[j - b[i]][kk - 1] + a[i]);
                }
            }
            if(f[j][s] >= n) break;
        }
        printf("%d\n", m - j);
    }
    return 0;
}

Fucker 2010-07-28 15:07 发表评论

HDU 2191 悼念512汶川大地震遇难同胞——珍惜现在，感恩生活

Fucker — Wed, 28 Jul 2010 06:10:00 GMT

多重背包

#include <stdio.h>
#include <string.h>

#define N 105
#define MAX(a, b) (a > b ? a : b)

int p[N], h[N], c[N], f[N];

void Complete(int cost, int weight, int n)
{
    for(int i = cost; i <= n; i++)
        f[i] = MAX(f[i], f[i - cost] + weight);
}

void Zero_One(int cost, int weight, int n)
{
    for(int i = n; i >= cost; i--)
        f[i] = MAX(f[i], f[i - cost] + weight);
}

int main()
{
    int t, n, m;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d", &n, &m);
        for(int i = 0; i < m; i++)
        {
            scanf("%d %d %d", &p[i], &h[i], &c[i]);
        }

        memset(f, 0, sizeof(f));

        for(int i = 0; i < m; i++)
        {
            int tmp = p[i] * c[i];
            if(tmp > n) Complete(p[i], h[i], n);
            else
            {
                int k = 1;
                while(k < c[i])
                {
                    Zero_One(k * p[i], k * h[i], n);
                    c[i] -= k;
                    k <<= 1;
                }
                Zero_One(c[i] * p[i], c[i] * h[i], n);
            }
        }
        printf("%d\n", f[n]);
    }
    return 0;
}

Fucker 2010-07-28 14:10 发表评论

HDU 1059 Dividing

Fucker — Mon, 26 Jul 2010 02:46:00 GMT

同PKU 1014 Dividing的一样，上次做SuQiang博客的那20道题目里剩下此题，因为是多重背包没有去切，今天把遗憾解决。

多重背包看来还是得按照伪代码上的写法，自己的写法还是有点问题。

#include <stdio.h>
#include <string.h>

#define N 60005
#define MAX(a, b) (a > b ? a : b)

int c[N];

void Complete(int cost, int weight, int m)
{
    for(int i = cost; i <= m; i++)
        c[i] = MAX(c[i], c[i - cost] + weight);
}

void Zero_One(int cost, int weight, int m)
{
    for(int i = m; i >= cost; i--)
        c[i] = MAX(c[i], c[i - cost] + weight);
}

int main()
{
    int cas = 1, sum, a[10];
    while(1)
    {
        sum = 0;
        for(int i = 1; i <= 6; i++)
        {
            scanf("%d", &a[i]);
            sum += i * a[i];
        }
        if(!sum) break;

        printf("Collection #%d:\n", cas++);
        if(sum & 1)
        {
            puts("Can't be divided.\n");
            continue;
        }
        memset(c, 0, sizeof(c));
        sum >>= 1;
        for(int i = 1; i <= 6; i++)
        {
            int t = i * a[i];
            if(t > sum) Complete(i, i, sum);
            else
            {
                int k = 1;
                while(k < a[i])
                {
                    Zero_One(k * i, k * i, sum);
                    a[i] -= k;
                    k <<= 1;
                }
                Zero_One(a[i] * i, a[i] * i, sum);
            }
        }
        if(c[sum] == sum) puts("Can be divided.\n");
        else puts("Can't be divided.\n");
    }
    return 0;
}

Fucker 2010-07-26 10:46 发表评论

HDU 2844 Coins

Fucker — Mon, 26 Jul 2010 02:35:00 GMT

多重背包，Cui tianyi大牛的背包九讲里面说的很详尽。

#include <stdio.h>
#include <string.h>

#define N 105
#define M 100005
#define MAX(a, b) (a > b ? a : b)

int a[N], c[N], f[M];

void Complete(int cost, int weight, int m)
{
    for(int i = cost; i <= m; i++)
        f[i] = MAX(f[i], f[i - cost] + weight);
}

void Zero_One(int cost, int weight, int m)
{
    for(int i = m; i >= cost; i--)
        f[i] = MAX(f[i], f[i - cost] + weight);
}

int main()
{
    int n, m;
    while(scanf("%d %d", &n, &m), n + m)
    {
        for(int i = 0; i < n; i++)
            scanf("%d", &a[i]);

        for(int i = 0; i < n; i++)
            scanf("%d", &c[i]);

        memset(f, 0, sizeof(f));

        for(int i = 0; i < n; i++)
        {
            int t = a[i] * c[i];
            if(t > m) Complete(a[i], a[i], m);
            else
            {
                int k = 1;
                while(k < c[i])
                {
                    Zero_One(k * a[i], k * a[i], m);
                    c[i] -= k;
                    k *= 2;
                }
                Zero_One(c[i] * a[i], c[i] * a[i], m);
            }
        }
        int ans = 0;
        for(int i = 1; i <= m; i++)
        {
            if(f[i] == i) ans++;
        }
        printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-07-26 10:35 发表评论

HDU 1171 Big Event in HDU

Fucker — Sun, 25 Jul 2010 07:59:00 GMT

多重背包，每个物品有数量上限限制。没有用二进制优化。

#include <stdio.h>
#include <string.h>

#define N 250005
#define MAX(a, b) (a > b ? a : b)

int c[N];

int main()
{
    int n, v[55], m[55], sum;
    while(scanf("%d", &n), n >= 0)
    {
        sum = 0;
        for(int i = 0; i < n; i++)
        {
            scanf("%d %d", &v[i], &m[i]);
            sum += v[i] * m[i];
        }
        memset(c, 0, sizeof(c));
        for(int i = 0; i < n; i++)
        {
            while(m[i]--)
            {
                for(int j = sum / 2; j >= v[i]; j--)
                {
                    c[j] = MAX(c[j], c[j - v[i]] + v[i]);
                }
            }
        }
        n = MAX(c[sum / 2], sum - c[sum / 2]);
        printf("%d %d\n", n, sum - n);
    }
    return 0;
}

Fucker 2010-07-25 15:59 发表评论

HDU 1203 I NEED A OFFER!

Fucker — Sun, 25 Jul 2010 03:59:00 GMT

01背包乘法，以前是读foreverlin的代码A的，今天才算搞明白一点了。

#include <stdio.h>
#include <string.h>

#define N 10005
#define M 1005
#define MIN(a, b) (a < b ? a : b)

int a[M];
double b[M], f[N];

int main()
{
    int n, m;
    while(scanf("%d %d", &n, &m), n + m)
    {
        for(int i = 0; i < m; i++)
        {
            scanf("%d %lf", &a[i], &b[i]);
            b[i] = 1 - b[i];
        }
        for(int i = 0; i <= n; i++) f[i] = 1;
        for(int i = 0; i < m; i++)
        {
            for(int j = n; j >= a[i]; j--)
            {
                f[j] = MIN(f[j], f[j - a[i]] * b[i]);
            }
        }
        printf("%.1lf%%\n", (1 - f[n]) * 100);
    }
    return 0;
}

Fucker 2010-07-25 11:59 发表评论

HDU 1114 Piggy-Bank

Fucker — Sun, 25 Jul 2010 03:39:00 GMT

完全背包问题，一个物品可以无限次的使用。还有需要注意的就是该题要求恰好装满背包时的最小值，初始化的时候除了f[0]=0之外，其余的为负无穷。

#include <stdio.h>
#include <string.h>

#define N 10005
#define INF 2139062144
#define MAX(a, b) (a > b ? a : b)

int c[N], w[N], f[N];

int main()
{
    int t, E, F, v, n;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d", &E, &F);
        v = F - E;
        scanf("%d", &n);
        for(int i = 0; i < n; i++)
        {
            scanf("%d %d", &w[i], &c[i]);
            w[i] = -w[i];
        }

        memset(f, 128, sizeof(f));
        f[0] = 0;
        for(int i = 0; i < n; i++)
        {
            for(int j = c[i]; j <= v; j++)
            {
                f[j] = MAX(f[j], f[j - c[i]] + w[i]);
            }
        }

        if(f[v] > -INF)printf("The minimum amount of money in the piggy-bank is %d.\n", -f[v]);
        else puts("This is impossible.");
    }
    return 0;
}

Fucker 2010-07-25 11:39 发表评论

HDU 2602 Bone Collector

Fucker — Fri, 23 Jul 2010 13:59:00 GMT

某群里有人吼是0/1背包，就去看了一下，果然很裸，顺便就A了。

#include <stdio.h>
#include <string.h>

#define MAXN 1005

int c[MAXN], vol[MAXN], val[MAXN];

int main()
{
    int t, N, V;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d", &N, &V);
        for(int i = 0; i < N; i++)
            scanf("%d", &val[i]);
        for(int i = 0; i < N; i++)
            scanf("%d", &vol[i]);
        memset(c, 0, sizeof(c));

        for(int i = 0; i < N; i++)
        {
            for(int j = V; j >= vol[i]; j--)
            {
                if(c[j] < c[j - vol[i]] + val[i])
                    c[j] = c[j - vol[i]] + val[i];
            }
        }
        printf("%d\n", c[V]);
    }
    return 0;
}

Fucker 2010-07-23 21:59 发表评论

HOJ 10024 积木城堡

Fucker — Sun, 04 Jul 2010 08:15:00 GMT

题意：给你n个城堡的积木长度，要求这n个城堡的高度相等的同时，使得城堡高度最高。

解法：求出每个城堡可能的所有高度，记录最低城堡的高度，然后依次往下枚举所有城堡都可能满足的高度即可。

#include <stdio.h>
#include <string.h>

#define N 10005

bool mk[105][N];

int main()
{
    int t, n, l, sum, ans;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        ans = N;
        memset(mk, 0, sizeof(mk));
        for(int i = 0; i < n; i++)
        {
            mk[i][0] = 1;
            sum = 0;
            while(scanf("%d", &l), l + 1)
            {
                for(int j = sum; j >= 0; j--)
                {
                    if(mk[i][j]) mk[i][j + l] = 1;
                }
                sum += l;
            }
            if(sum < ans) ans = sum;
        }
        int k;
        for(k = ans; k; k--)
        {
            sum = 0;
            for(int i = 0; i < n; i++)
            {
                if(mk[i][k]) sum++;
            }
            if(sum == n) break;
        }
        printf("%d\n", k);
    }
    return 0;
}

Fucker 2010-07-04 16:15 发表评论

PKU 3628 Bookshelf2

Fucker — Sun, 04 Jul 2010 07:22:00 GMT

题意：给定n个数，要求从这n个数中的选取一些数和sum大于指定数b，要求sum-b最小。

解法：刚开始可以把所有n个数全部相加得到sum，sum肯定大于b，令m=sum-b,要尽量在这m中多的减去原来在sum中的数，使得m最小；

即从这n个数种选取几个数，使得在其和不超过m的情况下最大,这不就是一个01背包问题么。解之。

#include <stdio.h>
#include <string.h>

#define N 1000005
#define MAX(a, b)(a > b ? a : b)

int v[N], h[25];

int main()
{
    int n, b, sum = 0;
    scanf("%d %d", &n, &b);
    for(int i = 0; i < n; i++)
    {
        scanf("%d", &h[i]);
        sum += h[i];
    }
    b = sum - b;
    for(int i = 0; i < n; i++)
        for(int j = b; j >= h[i]; j--)
        {
            v[j] = MAX(v[j], v[j - h[i]] + h[i]);
        }
    printf("%d\n", b - v[b]);
    return 0;
}

Fucker 2010-07-04 15:22 发表评论

UVA 10304 Optimal Binary Search Tree

Fucker — Sat, 03 Jul 2010 06:07:00 GMT

最优二叉搜索树，四边形优化貌似也是从这里衍生出来的定理。这题和矩阵链乘很像。

题意：给你一个排好序的关键字出现概率的集合。要求一个满足条件的最优二叉搜索树，至于最优二叉搜索树的定义在题目描述里面有。

w[i][j]表示集合中第i个到第j个元素的累积概率和。e[i][j]表示集合中使用第i个到第j个元素的最优二叉搜索树的花费，那么e[i][i] = 0;

那么状态转移方程就为:e[i][j] = e[i][k-1]+e[k+1][j]+w[i][j]-f[k](i<=k<=j),即枚举i到j之间的所有元素为根节点，最优结果e[1][n]即为所求。

#include <stdio.h>
#include <string.h>

#define N 255
#define INF 1 << 28

int e[N][N], w[N][N], f[N];

int main()
{
    int n;
    while(~scanf("%d", &n))
    {
        memset(w, 0, sizeof(w));
        memset(e, 0, sizeof(e));
        for(int i = 1; i <= n; i++)
            scanf("%d", &f[i]);

        for(int i = 1; i <= n; i++)
        for(int j = i; j <= n; j++)
            w[i][j] = w[i][j - 1] + f[j];

        for(int i = 2; i <= n; i++)
        for(int j = i - 1; j; j--)
        {
            e[j][i] = INF;
            for(int k = j; k <= i; k++)
            {
                if(e[j][k - 1] + e[k + 1][i] + w[j][i] - f[k] < e[j][i])
                {
                    e[j][i] = e[j][k - 1] + e[k + 1][i] + w[j][i] - f[k];
                }
            }
        }
        printf("%d\n", e[1][n]);
    }
    return 0;
}

Fucker 2010-07-03 14:07 发表评论

UVA 348 Optimal Array Multiplication Sequence

Fucker — Thu, 01 Jul 2010 09:29:00 GMT

经典DP，矩阵链乘，不过此题不要求算最小的相乘次数，而要把最优的解输出，那一个数组记录从i到j的最优分割，然后递归输出就行了。

而关于具体的转移方程资料到处都有。就不做说明了，具体参见代码。

代码是O(n^3)此方的解法，据说斯坦福大学的一片论文有O(nlogn)的，改天研究下。。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define N 15

struct Array
{
    int row, col;
}array[N];

int a[N][N], p[N][N];

void show(int left, int right)
{
    if(left < right)
    {
        printf("(");
        show(left, p[left][right]);
        printf(" x ");
        show(p[left][right] + 1, right);
        printf(")");
    }
    else if(left == right)
    {
        printf("A%d", left);
    }
}

int main()
{
    int n, cas = 0;
    while(scanf("%d", &n), n)
    {
        for(int i = 1; i <= n; i++)
            scanf("%d %d", &array[i].row, &array[i].col);

        memset(a, 127, sizeof(a));
        memset(p, 0, sizeof(p));
        for(int i = 1; i <= n; i++) a[i][i] = 0;
        for(int i = 2; i <= n; i++)
        {
            a[i - 1][i] = array[i - 1].row * array[i].row * array[i].col;
            p[i - 1][i] = i - 1;
        }

        for(int i = 3; i <= n; i++)
        for(int j = i - 2; j; j--)
        for(int k = j; k < i; k++)
        {
            int t = a[j][k] + a[k + 1][i] + array[j].row * array[k].col * array[i].col;
            if(a[j][i] > t)
            {
                a[j][i] = t;
                p[j][i] = k;
            }
        }
        printf("Case %d: ", ++cas);
        show(1, n);
        printf("\n");
    }
    return 0;
}

Fucker 2010-07-01 17:29 发表评论

UVA 10819 Trouble of 13-Dots

Fucker — Wed, 30 Jun 2010 07:09:00 GMT

好好的一个背包题目，非要弄个什么透支，没搞懂。

#include <stdio.h>
#include <string.h>

#define MAX(a, b) (a > b ? a : b)
#define N 105

int c[N * 150], p[N + N], v[N + N];

int main()
{
    int n, budget, ans;
    while(~scanf("%d %d", &budget, &n))
    {
        for(int i = 1; i <= n; i++)
            scanf("%d %d", &p[i], &v[i]);

        memset(c, 0, sizeof(c));

        for(int i = 1; i <= n; i++)
        for(int j = 10200; j >= p[i]; j--)
        {
            if(j == p[i]) c[j] = MAX(c[j], c[j - p[i]] + v[i]);
            else if(j > p[i] && c[j - p[i]]) c[j] = MAX(c[j], c[j - p[i]] + v[i]);
        }
        ans = 0;
        for(int i = 0; i < 10201; i++)
        {
            if((i > 2000 && i <= budget + 200) || i <= budget)
            {
                ans = ans > c[i] ? ans : c[i];
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-06-30 15:09 发表评论

UVA 10130 SuperSale

Fucker — Wed, 30 Jun 2010 04:04:00 GMT

自己怎么就那么的2呢？题目都读错了。。

简单背包，每个人都可以从这些类型的物品里取一个，求这些人能够取出的最大值。

当初看成每种类型的物品只有一个，这些人一共能取出的最大值。杯具~

#include <stdio.h>
#include <string.h>

#define N 1005
#define W 35

int p[N], w[N], c[W];

int main()
{
    int t, n, g, gw, sum;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        for(int i = 1; i <= n; i++)
            scanf("%d %d", &p[i], &w[i]);
        scanf("%d", &g);

        memset(c, 0, sizeof(c));
        for(int i = n; i; i--)
        for(int j = 30; j >= w[i]; j--)
        {
            if(c[j] < c[j - w[i]] + p[i])
            {
                c[j] = c[j - w[i]] + p[i];
            }
        }
        sum = 0;
        for(int k = 1; k <= g; k++)
        {
            scanf("%d", &gw);
            sum += c[gw];
        }
        printf("%d\n", sum);
    }
    return 0;
}

Fucker 2010-06-30 12:04 发表评论

UVA 990 Diving for gold

Fucker — Wed, 30 Jun 2010 03:31:00 GMT

0/1背包问题，和624类似，只是这次价值和花费不同，这次同样需要输出选择的物品。

输出恶心到我了，竟然PE两次。

#include <stdio.h>
#include <string.h>

#define T 1005
#define N 35

struct Treature
{
    int depth, time, value;
}treature[N];

int c[T];
bool p[N][T];

int main()
{
    int t, w, n, count, cas = 0;
    while(~scanf("%d %d", &t, &w))
    {
        if(cas) puts("");
        scanf("%d", &n);
        for(int i = 1; i <= n; i++)
        {
            int depth, value;
            scanf("%d %d", &depth, &value);
            treature[i].depth = depth;
            treature[i].time = 3 * depth * w;
            treature[i].value = value;
        }

        memset(c, 0, sizeof(c));
        memset(p, 0, sizeof(p));

        for(int i = n; i; i--)
        for(int j = t; j >= treature[i].time; j--)
        {
            if(c[j] < c[j - treature[i].time] + treature[i].value)
            {
                c[j] = c[j - treature[i].time] + treature[i].value;
                p[i][j] = 1;
            }
        }
        printf("%d\n", c[t]);
        count = 0;
        for(int i = 1, j = t; i <= n; i++)
            if(p[i][j])
            {
                count++;
                j -= treature[i].time;
            }
        printf("%d\n", count);
        for(int i = 1, j = t; i <= n; i++)
            if(p[i][j])
            {
                printf("%d %d\n", treature[i].depth, treature[i].value);
                j -= treature[i].time;
            }
        cas++;
    }
    return 0;
}

Fucker 2010-06-30 11:31 发表评论

UVA 624 CD

Fucker — Wed, 30 Jun 2010 02:59:00 GMT

0/1背包问题的最简单特殊情况，重量和价值相等。要求输出放入了哪些物品，顺序和输入的时候相同，这样从DP的时候从后面往前面递推就好了。

背包问题可以只用一个一维数组表示，这样节省空间。

#include <stdio.h>
#include <string.h>

#define W 10005

int c[W], l[25];
bool p[25][W];

int main()
{
    int w, n;
    while(~scanf("%d", &w))
    {
        scanf("%d", &n);
        for(int i = 1; i <= n; i++)
            scanf("%d", &l[i]);

        memset(c, 0, sizeof(c));
        memset(p, 0, sizeof(p));

        for(int i = n; i; i--)
        for(int j = w; j >= l[i]; j--)
        {
            if(c[j] < c[j - l[i]] + l[i])
            {
                c[j] = c[j - l[i]] + l[i];
                p[i][j] = 1;
            }
        }
        for(int i = 1, j = w; i <= n; i++)
            if(p[i][j])
            {
                printf("%d ", l[i]);
                j -= l[i];
            }
        printf("sum:%d\n", c[w]);
    }
    return 0;
}

Fucker 2010-06-30 10:59 发表评论

UVA 10271 Chopsticks

Fucker — Sat, 19 Jun 2010 04:14:00 GMT

题意：从一个非递减序列中找出k个3元组(x,y,z),其中x<=y<=z,一个三元组的代价是(x-y)^2，要求这k个三元组的代价和最小。

解法：DP，令a[i][j]表示从前i个数中选择j个3元组,那么转移方程为：a[i][j] = min(a[i-1][j],a[i-2][j-1]+w(l[i],l[i-1]))；很好理解，如果使用l[i]，那么肯定要和l[i-1]一起使用(因为序列是非递减的，可以证明),所以就有了第二个转移方程，如果不适用l[i]那么它就和i-1个数种选择j个三元组的结果一样，注意当3*j>i时无效。

还有一点需要注意的就是如何选取z确保z>=x>=y，看了人家的提示才知道，把数组从到小排列，这样就不需要考虑z的影响了。从发觉自己还没有领悟DP，状态设计还需要看人家的思路才能写出来，o(╯□╰)o

#include <stdio.h>
#include <string.h>
#include <algorithm>

#define N 5005
#define MIN(a, b) (a < b ? a : b)

int l[N], w[N], a[N][1010];

int cmp(int a, int b)
{
    return a > b;
}

int main()
{
    int t, k, n;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d %d", &k, &n);
        k += 8;
        for(int i = 1; i <= n; i++)
            scanf("%d", &l[i]);

        std::sort(l + 1, l + n + 1, cmp);
    //    for(int i = 1; i <= n; i++) printf("%4d", l[i]);
    //    printf("\n");

        for(int i = 2; i <= n; i++)
            w[i] = (l[i] - l[i - 1]) * (l[i] - l[i - 1]);

        memset(a, 127, sizeof(a));
        for(int i = 0; i <= n; i++) a[i][0] = 0;

        for(int i = 3; i <= n; i++)
        {
            for(int j = 1; j <= k && 3 * j <= i; j++)
            {
                a[i][j] = MIN(a[i - 1][j], a[i - 2][j - 1] + w[i]);
            }
        }
        printf("%d\n", a[n][k]);
    }
    return 0;
}

Fucker 2010-06-19 12:14 发表评论

UVA 10003 Cutting Sticks

Fucker — Thu, 17 Jun 2010 17:05:00 GMT

题目大意：将一段木棒按要求切割，每次切割都要付出与木棒长度相同的代价，求最小代价切割。
状态表示：d[x][y]表示[x，y]区间上切割所用的最小值，转移方程：d[x][y]=min{d[x][a[i]]+d[a[i]][y]+(y-x)|a[i]为[x，y]内的切割点}

#include <stdio.h>
#include <string.h>

#define N 55
#define INF 1 << 29
#define MIN(a, b) (a < b ? a : b)

int a[N], c[N][N];

int main()
{
    int l, n, d;
    while(scanf("%d", &l), l)
    {
        scanf("%d", &n);
        for(int i = 1; i <= n; i++)
            scanf("%d", &a[i]);

        a[0] = 0, a[n + 1] = l;
        for(int i = 0; i <= n; i++)
            c[i][i + 1] = 0;

        for(int i = 1; i <= n + 1; i++)
        {
            for(int j = i - 2; j >= 0; j--)
            {
                d = INF;
                for(int k = j + 1; k < i; k++)
                    d = MIN(d, c[j][k] + c[k][i]);
                c[j][i] = d + a[i] - a[j];
            }
        }
        printf("The minimum cutting is %d.\n", c[0][n + 1]);
    }
    return 0;
}

Fucker 2010-06-18 01:05 发表评论

UVA 116 Unidirectional TSP

Fucker — Wed, 16 Jun 2010 09:19:00 GMT

题意：题目翻译成中文就是无向旅行商，其实就是给你一个n*m的矩阵，要求一条从第一列到最后一列的最小花费的路径，上下可以互通。

解法：看到这题就觉得和The triangle类似，很快写出代码，输出路径没有问题，但是题目说如果有多条路径要求字典序最小的那个。我开始是从左往右推，网上看了解题报告说这样做不能保证字典序最小，要从右往左推，于是改了代码就A了，至于为什么这样做就能保证字典序最小还没有想明白。

#include <stdio.h>
#include <string.h>

#define N 15
#define M 105
#define INF 1 << 29

int dir[3][2] = {{-1, -1}, {0, -1}, {1, -1}};
int a[N][M], b[N][M], p[N][M], s[M];

int main()
{
    int n, m, x, y, ans, top;
    while(~scanf("%d %d", &n, &m))
    {
        for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            scanf("%d", &a[i][j]);

        memset(p, -1, sizeof(p));
        for(int i = 1; i <= n; i++)
            b[i][m] = a[i][m];

        for(int i = 1; i <= n; i++)
        for(int j = 1; j < m; j++)
            b[i][j] = INF;

        for(int j = m ; j > 1; j--)
        for(int i = 1; i <= n; i++)
        {
            for(int k = 0; k < 3; k++)
            {
                x = i + dir[k][0];
                y = j + dir[k][1];
                if(x < 1) x = n;
                if(x > n) x = 1;
                if(b[i][j] + a[x][y] < b[x][y])
                {
                    b[x][y] = b[i][j] + a[x][y];
                    p[x][y] = k;
                }
            }
        }

        ans = INF, y = 1, top = 0;
        for(int i = 1; i <= n; i++)
        {
            if(b[i][1] < ans)
            {
                ans = b[i][1];
                x = i;
            }
        }
        s[top++] = x;
        while(p[x][y] != -1)
        {
            int t = p[x][y];
            x -= dir[t][0], y++;
            if(x > n) x = 1;
            if(x < 1) x = n;
            s[top++] = x;
        }
        for(int i = 0; i < top; i++)
        {
            printf("%d", s[i]);
            if(i != top - 1) printf(" ");
            else printf("\n");
        }
        printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-06-16 17:19 发表评论

UVA 10154 Weights and Measures

Fucker — Mon, 14 Jun 2010 10:23:00 GMT

题意：给你一些海龟，他们都有各自的重量和载重能力，要求把海龟堆成一落，要求每个海龟在称重的范围之内。

解法：感觉有点像背包问题。用a[i][j]表示从前i个海龟中选择j个的最小重量和，转移方程为：a[i][j] = min(a[i-1][j],a[i-1][j-1]+t[i].st)(i>=j)，因为每个海龟不能超过其最大载重能力，所以第二个转移方程的条件是a[i-1][j-1]<=t[i].st即前面i-1个海龟中选择j-1个海龟的最小重量不能超过当前海龟的载重值。

#include <stdio.h>
#include <string.h>
#include <algorithm>

#define N 6000
#define INF 1 << 29
#define MIN(a, b) (a < b ? a : b)

struct turtle
{
    int wt, st;
}t[N];

int a[N][N];

int cmp(turtle a, turtle b)
{
    return a.st < b.st;
}

int main()
{
    int n = 1, ans = 1;
    while(~scanf("%d %d", &t[n].wt, &t[n].st))
    {
        t[n].st -= t[n].wt;
        n++;
    }
    n--;
    for(int i = 0; i <= n; i++)
    for(int j = 0; j <= n; j++)
        a[i][j] = INF;
    for(int i = 0; i <= n; i++)
        a[i][0] = 0;
    std::sort(t + 1, t + n + 1, cmp);
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= i; j++)
        {
            a[i][j] = a[i - 1][j];
            if(a[i - 1][j - 1] <= t[i].st)
                a[i][j] = MIN(a[i][j], a[i - 1][j - 1] + t[i].wt);
        }
    }
    for(int i = n; i; i--)
        if(a[n][i] < INF)
        {
            ans = i;
            break;
        }
    printf("%d\n", ans);
    return 0;
}

Fucker 2010-06-14 18:23 发表评论

UVA 10069 Distinct Subsequences

Fucker — Mon, 14 Jun 2010 08:43:00 GMT

题意：在一个母串X中找出字串Z出现的最大次数。

解法：很明显的DP；状态表示：用a[i][j]表示字串的前i个在母串的前j个中出现得最大次数；转移方程：始终有a[i][j] = a[i][j-1]，因为字串前i个在母串前j-1个中出现的次数显然也会在母串前j个出现，当x[j]==z[i]时，还要加上字串前i-1个在母串前j-1个出现的次数。可以转化为一维的，具体见代码：

#include<iostream>
#include<algorithm>
using namespace std;
#define Base 1000000000
#define Cap 30
typedef long long hugeint;

struct bignum
{
    int Len;
    int Data[Cap];
    bignum() : Len(0){}
    bignum(const bignum &V) : Len(V.Len)
    {
        memcpy(Data,V.Data,Len * sizeof*Data);
    }
    bignum(int V) : Len(0)
    {
        for(;V > 0;V /= Base)
        Data[Len++] = V % Base;
    }
    bignum &operator = (const bignum &V)
    {
        Len = V.Len;
        memcpy(Data,V.Data,Len * sizeof*Data);
        return *this;
    }
    int &operator[](int Index)
    {
        return Data[Index];
    }
    int operator[](int Index) const
    {
        return Data[Index];
    }
};

bignum operator+(const bignum &A, const bignum &B)
{
    bignum R;
    int i;
    int Carry = 0;
    for(i = 0; i < A.Len || i < B.Len || Carry > 0; i++)
    {
        if(i < A.Len)
            Carry += A[i];
        if(i < B.Len)
            Carry += B[i];
        R[i] = Carry % Base;
        Carry /= Base;
    }
    R.Len = i;
    return R;
}

ostream& operator<<(ostream &Out, const bignum &V)
{
    int i;
    Out << (V.Len == 0 ? 0 : V[V.Len - 1]);
    for(i = V.Len - 2; i >= 0; i--)
    for(int J = Base / 10; J > 0; J /= 10)
        Out << V[i] / J % 10;
    return Out;
}

#define M 105
#define N 10005

bignum d[M];
char s1[N], s2[M];

int main()
{
    int t, l1, l2;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%s %s", &s1, &s2);
        l1 = strlen(s1), l2 = strlen(s2);
        for(int i = 1; i <= l2; i++) d[i] = bignum(0);
        d[0] = bignum(1);
        for(int i = 1; i <= l1; i++)
        for(int j = l2; j >= max(l2 - l1 + i, 1); j--)
        {
            if(s1[i - 1] == s2[j - 1])
            {
                d[j] = d[j] + d[j - 1];
            }
        }
        cout <<d[l2]<<endl;
    }
    return 0;
}

Fucker 2010-06-14 16:43 发表评论

UVA 10131 Is Bigger Smarter

Fucker — Sun, 13 Jun 2010 07:52:00 GMT

命名很简单的一道最长递减子序列，UVA上的题就是麻烦，还要处理这七七八八的其它东西，不过练练coding能力也还蛮好的。

#include <stdio.h>
#include <algorithm>

#define N 1005

struct elephant
{
    int id, wt, iq;
}e[N];

int b[N], pre[N];

int cmp(elephant a, elephant b)
{
    return a.wt < b.wt;
}

int main()
{
    int n = 0, cur, ans, stack[N], top = 0;
    while(~scanf("%d %d", &e[n].wt, &e[n].iq))
    {
        b[n] = 1;
        pre[n] = 0;
        e[n].id = n;
        n++;
    }
    std::sort(e, e + n, cmp);
//    for(int i = 0; i < n; i++)
//        printf("%d %d %d\n", e[i].wt, e[i].iq, e[i].id);
    ans = 1;
    for(int i = 1; i < n; i++)
    {
        for(int j = 0; j < i; j++)
        {
            if(e[i].wt > e[j].wt && e[i].iq < e[j].iq && b[i] <= b[j])
            {
                b[i] = b[j] + 1;
                pre[i] = j;
            }
        }
        if(b[i] > ans)
        {
            cur = i;
            ans = b[i];
        }
    }
    printf("%d\n", ans);
    while(cur)
    {
        stack[top++] = e[cur].id + 1;
        cur = pre[cur];
    }
    for(int i  = top - 1; i >= 0; i--)
        printf("%d\n", stack[i]);
    return 0;
}

Fucker 2010-06-13 15:52 发表评论

PKU 1179 Polygon

Fucker — Sun, 13 Jun 2010 05:37:00 GMT

题意：给定一多边形，边带两种运算符号，点带权值。删除一条边后变成一条链，求这条链的最大值。可以任意删除一条边，任意修改运算顺序。

解法：设dp[i][j]表示这条链上从i到j段的最大值，那么它可以分为两段来求,dp[i][k],dp[k+1][j],当它们之间是'+'号时，问题的求解也是最大值，但若为'*'号，子问题就不一定为最大值了，因为两个负数越小，相乘结果越大，所以要加一维,用dp[i][j][0]表示i到j段的最小值，dp[i][j][1]表示最大值，具体转移方程见代码。最后就是枚举删除的边，保存最大的链值就可以了。

#include <stdio.h>
#include <string.h>

#define N 55
#define INF 1 << 29
#define MIN(a, b) (a < b ? a : b)
#define MAX(a, b) (a > b ? a : b)

int DP(char op[][5], int v[], int n)
{
    int dp[N][N][2];
    for(int i = 0; i < n; i++)
        dp[i][i][0] = dp[i][i][1] = v[i];

    for(int j = 1; j < n; j++)
    {
        for(int i = j - 1; i >= 0; i--)
        {
            dp[i][j][0] = INF;
            dp[i][j][1] = -INF;
            for(int k = i; k < j; k++)
            {
                if(!strcmp(op[k], "t"))
                {
                    dp[i][j][0] = MIN(dp[i][j][0], dp[i][k][0] + dp[k + 1][j][0]);
                    dp[i][j][1] = MAX(dp[i][j][1], dp[i][k][1] + dp[k + 1][j][1]);
                }
                else
                {
                    dp[i][j][0] = MIN(dp[i][j][0], dp[i][k][0] * dp[k + 1][j][0]);
                    dp[i][j][0] = MIN(dp[i][j][0], dp[i][k][0] * dp[k + 1][j][1]);
                    dp[i][j][0] = MIN(dp[i][j][0], dp[i][k][1] * dp[k + 1][j][0]);
                    dp[i][j][1] = MAX(dp[i][j][1], dp[i][k][0] * dp[k + 1][j][0]);
                    dp[i][j][1] = MAX(dp[i][j][1], dp[i][k][1] * dp[k + 1][j][1]);
                }
            }
        }
    }
    return dp[0][n - 1][1];
}

int main()
{
    int n, t, ans[N], mmax;
    char op[N][5], OP[N][5];
    int v[N], V[N];
    while(~scanf("%d", &n))
    {
        for(int i = 0; i < n; i++)
            scanf("%s %d", &op[i], &v[i]);
        mmax = -INF;
        for(int k = 0; k < n; k++)
        {
            for(int i = 0; i < n; i++)
            {
                strcpy(OP[i], op[(i + k + 1) % n]);
                V[i] = v[(i + k) % n];
            //    printf("%s %d ", OP[i], V[i]);
            }
        //    printf("\n");
            ans[k] = DP(OP, V, n);
            if(ans[k] > mmax) mmax = ans[k];
        }
        printf("%d\n", mmax);
        for(int i = 0; i < n; i++)
            if(ans[i] == mmax)
            {
                printf("%d ", i + 1);
            }
        printf("\n");
    }
    return 0;
}

Fucker 2010-06-13 13:37 发表评论

PKU 1160 Post Office

Fucker — Tue, 08 Jun 2010 10:04:00 GMT

感觉又是一道经典的DP。

题意：给定v个村庄和p个邮局(v>=p)，v个村庄在一条直线上，用一个整数值表示。求最佳的布置邮局方案使得每个村庄到最近的邮局距离之和最少。

思路：状态表示很容易想到，用opt[i][j]表示前i个邮局覆盖前j个村庄的最小距离之和。那么状态转移方程应该怎么表示呢？从当前状态opt[i][j]增加一个邮局，我们可以得到它到opt[i+1][j+k]的值(j+k<=v)，即我们需要知道在任意两个村庄之间增加一个邮局的花费是多少，这样我们需要一个数组cost[i][j]保存在村庄i和j之间增加一个邮局所需要的花费，这部分需要预处理一下。这样我们就可以轻易地写出代码来了。

注意的地方：i>=j时显然opt[i][j]=0,因为邮局比村庄多。还有就是转移方程中的opt[i+1][j+k] = opt[i][j]+cost[j+1][j+k];注意cost中是从j+1到j+k的村庄中增加一个邮局的花费，因为第j个村庄的花费已经包含在opt[i][j]中了，开始这里写错了，答案一直不对。

#include <stdio.h>
#include <string.h>

#define N 305

int p[N], cost[N][N], opt[N][N];

inline int abs(int x)
{
    return x > 0 ? x : -x;
}

int main()
{
    int village, post;
    while(~scanf("%d %d", &village, &post))
    {
        if(post >= village)
        {
            puts("0");
            continue;
        }
        memset(cost, 0, sizeof(cost));
        memset(opt, 127, sizeof(opt));
        for(int i = 1; i <= village; i++)
            scanf("%d", &p[i]);
        for(int i = 1; i <= village; i++)
            for(int j = i + 1; j <= village; j++)
            {
                int mid = (i + j) >> 1;
                for(int k = i; k <= j; k++)
                    cost[i][j] += abs(p[k] - p[mid]);
            }
        for(int i = 1; i <= village; i++)
            opt[1][i] = cost[1][i];
        for(int i = 1; i < post; i++)
            for(int j = i + 1; j <= village; j++)
            {
                for(int k = 1; j + k <= village; k++)
                {
                    if(opt[i][j] + cost[j + 1][j + k] < opt[i + 1][j + k])
                    {
                        opt[i + 1][j + k] = opt[i][j] + cost[j + 1][j + k];
                    }
                }
            }
        printf("%d\n", opt[post][village]);
    }
    return 0;
}

Fucker 2010-06-08 18:04 发表评论

HDU 1231 最大连续子序列

Fucker — Tue, 08 Jun 2010 06:58:00 GMT

DP水题，以前做过，之所以重做事因为原来并没有理解状态转移方程的意义。今天才恍然明白。

令sum表示以i-1个元素结尾的最大连续字段和，则当sum>0时，sum+=a[i]，否则sum=a[i];

因为当sum>0时sum加上当前值a[i]肯定比a[i]要大，而Sum<0时肯定要小，所以sum<0时，sum=a[i]。

#include <stdio.h>

int main()
{
    int n, sum, ans, st, ed, x, y, a[10005];
    while(scanf("%d", &n), n)
    {
        for(int i = 0; i < n; i++)
            scanf("%d", &a[i]);
        ans = sum = x = y = st = ed = a[0];
        for(int i = 1; i < n; i++)
        {
            if(sum > 0) sum += a[i], ed = a[i];
            else sum = a[i], st = ed = a[i];
            if(sum > ans)
            {
                ans = sum;
                x = st, y = ed;
            }
        }
        if(ans < 0) ans = 0, x = a[0], y = a[n - 1];
        printf("%d %d %d\n", ans, x, y);
    }
    return 0;
}

Fucker 2010-06-08 14:58 发表评论

PKU 1088 滑雪

Fucker — Tue, 08 Jun 2010 06:08:00 GMT

传说中经典DP，记忆化搜索？其实就是在一个二维数组中求一个最长下降的子序列的长度。

其实就是从每个元素开始找以它为起始点的最长下降子序列，当递归到该点比周围所有的点都小时即返回，

自低向上的方法，注意与广搜不同，广搜是自顶向下。

以后每个点的计算都可以用到以前的结果，因为这是无后效性的？这就是传说中的记忆化？

#include <stdio.h>
#include <string.h>

#define N 105
#define INF 1 << 28

int r, c;
int h[N][N], a[N][N];
int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

int dfs(int x, int y)
{
    if(a[x][y]) return a[x][y];
    int max = 0, t;
    for(int i = 0; i < 4; i++)
    {
        int xx = x + dir[i][0];
        int yy = y + dir[i][1];
        if(xx < 0 || xx >= r || yy < 0 || yy >= c) continue;
        if(h[xx][yy] < h[x][y])
        {
            t = dfs(xx, yy);
            max = max > t ? max : t;
        }
    }
    a[x][y] = max + 1;
    return max + 1;
}

int main()
{
    int ans;
    while(~scanf("%d %d", &r, &c))
    {
        for(int i = 0; i < r; i++)
            for(int j = 0; j < c; j++)
            {
                scanf("%d", &h[i][j]);
                a[i][j] = 0;
            }
        ans = -INF;
        for(int i = 0; i < r; i++)
            for(int j = 0; j < c; j++)
            {
                int t = dfs(i, j);
                if(t > ans) ans = t;
            }
        printf("%d\n", ans);
    }
    return 0;
}

Fucker 2010-06-08 14:08 发表评论