C++博客-第七天堂-文章分类-动态规划

zjut1418:Max Xor Sub-sequence II

LLawliet — Sat, 15 Oct 2011 14:15:00 GMT

Max Xor Sub-sequence II
Time Limit:1000MS Memory Limit:32768K

Description:

Give you a sequence of integer numbers which are 1 or 0. You are to find the number of consecutive sub-sequence, which the xor value between all these numbers has the maximum value. The first number of the sequence is 1 and the last is 1. There are (n+1) 1’s in the sequence. N numbers will be given. The i-th number is the index of (i+1)-th 1 minus the index of i-th 1. For example: if the sequence is 1010100010001, 4 2 2 4 4 will be given.

Input:

There are multiple cases. For each case: Line 1: A single integer N (1<=N<=20000). Followed N integers ranging from 1 to 20000.

Output:

For each case output the result in a single line.

Sample Input:

Sample Output:

49
70

Hint:

1.1 ^ 1 = 0, 1 ^ 0 = 1, 0 ^ 1 = 1, 0 ^ 0 = 0. 2.In the example, sub-sequence 10 has the maximum value ‘cause 1 xor 0 = 1;the same as 10101, 1010100010001, and so on.

算不上DP的DP......就是处理01串的奇偶性.....

DP[i][j]表示第i个1，j有6种情况。
dp[i][0] = dp[i - 1][1] 表示偶数个1，且最后一个1在末尾。
dp[i][1] = dp[i - 1][0] + dis 表示奇数个1，且最后一个1在末尾。
dp[i][2] = f[i - 1][2] + f[i - 1][0] 表示偶数个1，且最后一个1不在末尾。
dp[i][3] = f[i - 1][3] + f[i - 1][1] 表示偶数个1，且最后一个1不在末尾。
dp[i][4] = f[i - 1][4] + (dis - 1) * f[i - 1][0] 表示偶数个1，且最后一个是0不在末尾。
dp[i][5] = f[i - 1][5] + (dis - 1) * f[i - 1][0] 表示偶数个1，且最后一个是0不在末尾。
上面六个关系式列举了所以情况，但是只用到了(dp[i][0], dp[i][1], dp[i][3], dp[i][5])四个式子。

友情提示，ans是超过int的，用long long吧，我因为这个吃了三次WA.....

代码：

#include

using namespace std;

int main()

{

long long dp[20010][7];

long long n;

long long dis;

while (cin >> n)

{

memset(dp, 0, sizeof(dp));

dp[1][0] = 0;

dp[1][1] = 1;

for (long long i = 2; i <= n + 1; ++i)

{

cin >> dis;

dp[i][0] = dp[i - 1][1];

dp[i][1] = dp[i - 1][0] + dis;

dp[i][3] = dp[i - 1][3] + dp[i - 1][1];

dp[i][5] = dp[i - 1][5] + (dis - 1) * dp[i - 1][1];

}

cout << dp[n + 1][1] + dp[n + 1][3] + dp[n + 1][5] << endl;

}

return 0;

}

LLawliet 2011-10-15 22:15 发表评论

HUST1380:NumberPyramids

LLawliet — Sat, 15 Oct 2011 14:15:00 GMT

NumberPyramids

Time Limit: 20 Sec Memory Limit: 128 MB
Submissions: 103 Solved: 41

Description

Suppose that there are N numbers written in a row. A row above this one consists of N-1 numbers, the i-th of which is the sum of the i-th and (i+1)-th elements of the first row. Every next row contains one number less than the previous one and every element is the sum of the two corresponding elements in the row below. The N-th row contains a single number. For example, if the initial numbers are {2,1,2,4}, the whole structure will look like this:

15
6 9
3 3 6
2 1 2 4

We shall refer to such a structure as a number pyramid. Two number pyramids are equal if all the numbers at corresponding positions are equal. Given ints baseLength and top, compute the total number of different number pyramids consisting of positive integers, having baseLength elements in the first row and the value at the top equal to top. Since the number of such pyramids might be enormous, return the result modulo 1,000,000,009.

Input

Two numbers -- baseLength and top.
baseLengthwill be between 2 and 1,000,000, inclusive.
topwill be between 1 and 1,000,000, inclusive.

Output

The total number of different number pyramids Constraints

Sample Input

Sample Output

HINT

1) The following are two possible pyramids with 3 numbers in the base and the number 5 at the top:

2) The only number pyramid with base of size 5 and 16 at the top looks like this:

Source

Topcoder SRM

非常V5的一道题，一开是以为但是DP，1,000,000的数据范围真的有点不能接受......
看了一个大牛的题解，用数论证明了这个题可以转化成多重背包.....

思路：
首先，我们可以证明金字塔最顶端的数和最低端的数是有关系的，关系就是
C⁰_N-1*a_{0 +}C¹_N-1*a_{1 + C}²_n-1_*a_{2 + ......}C^n-1_n-1_*a_n-1= T_（1）

而且因为T <= 1,000,000。可以推出n最大是20.....
继续观察上述（1），因为必须符合金字塔，所以a序列都至少为1，所以，我们可以发现，先用T减去每个系数（因为至少一次），之后用那n-1个数做多重背包，求T的方案就行了。

复杂度是(N * 1,000,000)，可以接受。

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;

const int mod = 1000000009;
int dp[1000100];
int n, top;
int c[21][21];
void init()
{
    for (int i = 1; i < 21; ++i)
    {
        c[i][0] = c[i][i]  = 1;
        c[i][1] = c[i][i - 1] = i;
        for (int j = 2; j < i - 1; ++j)
        {
            c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
        }
    }
}

int work(int n, int top)
{
    if (n > 20) return 0;
    if (1 << (n - 1) > top) return 0;
    top -= 1 << (n - 1);
    memset(dp, 0, sizeof(dp));
    dp[0] = 1;
    for (int i = 0; i <= n - 1; ++i)
    {
        for (int k = 0; k <= top; ++k)
        {
            if ((dp[k] && k + c[n - 1][i] <= top) || k == 0)
            {
                dp[k + c[n - 1][i]] = (dp[k + c[n - 1][i]] + dp[k]) % mod;
            }
        }
    }
    return dp[top];
}

int main()
{
    memset(c, -1, sizeof(c));
    init();
    while (scanf("%d%d", &n, &top) != EOF)
    {
        printf("%d\n", work(n ,top));
    }
    return 0;
}

LLawliet 2011-10-15 22:15 发表评论

HDU3022:Sum of Digits

LLawliet — Sat, 15 Oct 2011 14:14:00 GMT

Sum of Digits

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 149 Accepted Submission(s): 46

Problem Description

Petka thought of a positive integer n and reported to Chapayev the sum of its digits and the sum of its squared digits. Chapayev scratched his head and said: "Well, Petka, I won't find just your number, but I can find the smallest fitting number." Can you do the same?

Input

The first line contains the number of test cases t (no more than 10000). In each of the following t lines there are numbers s1 and s2 (1 ≤ s1, s2 ≤ 10000) separated by a space. They are the sum of digits and the sum of squared digits of the number n.

Output

For each test case, output in a separate line the smallest fitting number n, or "No solution" if there is no such number or if it contains more than 100 digits.

Sample Input

Sample Output

9
No solution
1122
111112

Source

2009 Multi-University Training Contest 6 - Host by WHU

Recommend

gaojie

根据output的提示，结果不可能大于100位，我们可以猜出，s1最大就是900，s2最大是8100，所以，完全可以(s1 * s2)的复杂度。
dp[i][j] = min(dp[i - k][j - k * k] + 1, dp[i][j])，其中i表示和，j表示平方和是，k表示多出最高位是k，dp数组记录位数，同时开一个d数组记录可行方案的首位。

根据贪心思想，让结果最小，所以先尽量求出最小的位数，之后根据位数构造最小的数。得出最小位数后，可以递归求出答案（d数组记录的是可行方案的首位，所以递归很好实现。）

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;

int dp[901][8101], d[901][8101];
int T, n, m;

int main()
{
    memset(dp, 0, sizeof(dp));
    for (int i = 1; i <= 9; ++i)
    {
        dp[i][i * i] = 1;
        d[i][i * i] = i;
    }
    for (int i = 1; i <= 900; ++i)
    {
        for (int j = i; j <= 8100; ++j)
        {
            for (int k = 1; k <= 9; ++k)
            {
                if (i < k || j < k * k) break;
                if (dp[i - k][j - k * k] == 0 || dp[i - k][j - k * k] == 100) continue;
                if (dp[i][j] == 0 || dp[i - k][j - k * k] + 1 < dp[i][j])
                {
                    dp[i][j] = dp[i - k][j - k * k] + 1;
                    d[i][j] = k;
                }
            }
        }
    }
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d%d", &n, &m);
        if (n > 900 || m > 8100 || dp[n][m] == 0)
        {
            printf("No solution\n");
            continue;
        }
        while (dp[n][m])
        {
            int dig = d[n][m];
            printf("%d", dig);
            n -= dig;
            m -= dig * dig;
        }
        printf("\n");
    }
    return 0;
}

LLawliet 2011-10-15 22:14 发表评论

HDU2929:Bigger is Better

LLawliet — Sat, 15 Oct 2011 14:14:00 GMT

Bigger is Better

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 559 Accepted Submission(s): 155

Problem Description

Bob has n matches. He wants to compose numbers using the following scheme (that is, digit 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 needs 6, 2, 5, 5, 4, 5, 6, 3, 7, 6 matches):

Write a program to make a non-negative integer which is a multiple of m. The integer should be as big as possible.

Input

The input consists of several test cases. Each case is described by two positive integers n (n ≤ 100) and m (m ≤ 3000), as described above. The last test case is followed by a single zero, which should not be processed.

Output

For each test case, print the case number and the biggest number that can be made. If there is no solution, output -1.Note that Bob don't have to use all his matches.

Sample Input

6 3
5 6
0

Sample Output

Case 1: 111
Case 2: -1

Source

2006 Asia Regional Xi-An

Recommend

lcy

06年区域赛，西安赛区的B题，佳哥出的，犀利的DP。
一开始看此题，认为是数学方法加构造答案，推了一会就放弃了，之后看了同场那道网络流的题，不过鉴于我对于那道网络流思路相当恶心，就返回继续思考这道题。
之后，发现这道题可以套用我昨天那道DP的转移方程。
dp[i][j] = max{dp[i][j], dp[i + a[k]][(j * 10 + k) % m]}，其中，i表示用了i个木棍，j表示i个木棍构成的数mod m后是j，dp[i][j]表示构成这个最大数的长度。（因为是求mod，可以想到取mod后的状态，这样可以有效的减少状态数目。）
说一下佳哥题解，也是让我WA了无数次的坑。
关于那个dp[i][j]的转移，我们可以看出每次转移的时候，添加数字k是添加在了末尾一位，但我一开是dp是添加在了首位，佳哥说添加首位是错误的，但没有给出证明，我找到了反例：11 6，应该是774，但我一开是得的是747，不过为什么错，我无法证明了.....
在获得上述转移状态后，我们可以用d数组记录相应状态下，最优解的最后一位，这样我们输出答案就可以从第一位递归寻找了。
至于无解的情况，只要n>=6都会有解，因为0是六根火柴......
其他思路：dp[i][j]记录最优答案，这样会涉及到大数运算。
代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 101;
const int maxm = 3001;
const int used[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};

typedef long long LL;

LL f[maxn][maxm], g[maxn][maxm];
LL n, m, i, j, k, u, v, Len, task;

LL max(LL i, LL j)
{
    if (i > j) return i;
    return j;
}

void printf(LL x, LL y)
{
    LL u, v;
    while (g[x][y] != 10)
    {
        u = x + used[g[x][y]];
        v = (y * 10 + g[x][y]) % m;
        cout << g[x][y];
        x = u;
        y = v;
    }
    cout << endl;
}

int main()
{
    task = 0;
    while (cin >> n && n)
    {
        cin >> m;
        printf("Case %d: ", ++task);
        memset(f, -1, sizeof(f));
        Len = 0;
        f[0][0] = 0;
        for (i = 0; i <= n; ++i)
        {
            for (j = 0; j <= m - 1; ++j)
            {
                if (f[i][j] >= 0)
                {
                    for (k = 0; k <= 9; ++k)
                    {
                        if (i + used[k] <= n)
                        {
                            if (i == 0 && k == 0) continue;
                            u = i + used[k];
                            v = (j * 10 + k) % m;
                            f[u][v] = max(f[u][v], f[i][j] + 1);
                            if (v == 0) Len = max(Len, f[u][v]);
                        }
                    }
                }
            }
        }
        memset(g, -1, sizeof(g));
        for (i = n; i >= 0; --i)
        {
            for (j = 0; j <= m - 1; ++j)
            {
                if (f[i][j] >= 0)
                {
                    if (f[i][j] == Len && j == 0)
                    {
                        g[i][j] = 10;
                        continue;
                    }
                    for (k = 9; k >= 0; --k)
                    {
                        if (i + used[k] <= n)
                        {
                            u = i + used[k];
                            v = (j * 10 + k) % m;
                            if (f[u][v] == f[i][j] + 1 && g[u][v] >= 0)
                            {
                                g[i][j] = k;
                                break;
                            }
                        }
                    }
                }
            }
        }
        if (g[0][0] > 0 && g[0][0] != 10) printf(0, 0);
        else
        if (n >= 6) cout << 0 << endl;
        else
        cout << -1 << endl;
    }
    return 0;
}

LLawliet 2011-10-15 22:14 发表评论

HDU3022:Sum of Digits

LLawliet — Sat, 15 Oct 2011 14:13:00 GMT

Sum of Digits

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 149 Accepted Submission(s): 46

Problem Description

Input

Output

For each test case, output in a separate line the smallest fitting number n, or "No solution" if there is no such number or if it contains more than 100 digits.

Sample Input

Sample Output

9
No solution
1122
111112

Source

2009 Multi-University Training Contest 6 - Host by WHU

Recommend

gaojie

LLawliet 2011-10-15 22:13 发表评论