dp 2016.10.20

1、 UVa 1375  Matches（火柴）

解题思路：

dp[i] 表示恰好用 i 根火柴时可以组成的正整数个数
如果用了 i 根火柴，剩余火柴仍然能组成数字 j 时， 显然 dp[i+c[j]] 应该加上 dp[i]

这里初始化 dp[0] = 1 很巧妙，不用纠结
显然这样初始化以后 dp[2] = dp[2] + dp[0] = 1

最后答案就是 dp[1] + dp[2] + ... + dp[n] 了

再要注意的是 N >= c[0] 的时候要再加构成 0 的情况，也就是再加1

这题要先打表，不然会超时

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <bitset>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int, int> Pair;

const ull mod = 1e9 + 7;
const int INF = 0x7fffffff;
const int maxn = 2000 + 10;

class bign {
public:
    int len, num[maxn];
    bign();
    bign operator = (const char* s);
    bign operator = (int a);
    bign operator + (const bign& a) const;
    bign(const char* s);
    bign(int a);
    void Print(void);
};

bign dp[maxn];
int key[20] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    int N;
    dp[0] = 1;
    for (int i = 0; i < maxn; ++i) {
        for (int j = 0; j < 10; ++j) {
            if (!(i == 0 && j == 0) && i + key[j] < maxn) {
                dp[i + key[j]] = dp[i + key[j]] + dp[i];
            }
        }
    }
    dp[6] = dp[6] + 1;
    for (int i = 2; i < maxn; ++i) {
        dp[i] = dp[i] + dp[i-1];
    }
    while (scanf("%d", &N) != EOF) {
        dp[N].Print();
    }
    return 0;
}

bign::bign()
{
    memset(num, 0, sizeof(num));
    len = 1;
}

bign bign::operator = (const char* s)
{
    len = strlen(s);
    for (int i = 0; i < len; ++i) {
        num[i] = s[len-i-1] - '0';
    }
    return *this;
}

bign bign::operator = (int a)
{
    char s[maxn];
    sprintf(s, "%d", a);
    *this = s;
    return *this;
}

bign::bign(const char* s)
{
    *this = s;
}

bign::bign(int a)
{
    *this = a;
}

bign bign::operator + (const bign& a) const
{
    bign ret;
    ret.len = 0;
    for (int i = 0, g = 0; g != 0 || i < max(len, a.len); ++i) {
        int x = g;
        if (i < len) {
            x += num[i];
        }
        if (i < a.len) {
            x += a.num[i];
        }
        ret.num[ret.len++] = x % 10;
        g = x / 10;
    }
    while (ret.len > 1 && ret.num[ret.len-1] == 0) {
        --ret.len;
    }
    return ret;
}

void bign::Print(void)
{
    for (int i = len-1; i >=0; --i) {
        printf("%d", num[i]);
    }
    printf("\n");
}

2、HDU 5009 Paint Pearls

解题思路：

解法一：

参考：http://blog.csdn.net/lvshubao1314/article/details/40895825

dp[i] 表示第 i 个珍珠涂完色以后的最小花费，所以有 dp[j] = min(dp[j], dp[i] + cnt*cnt)，cnt 为从第 i+1 到 j 个珍珠有几种颜色

加剪枝以后的 O(n^2) 勉强跑了 1s 多，显然 O(n^2*logn) 过不了，所以离散化以后要做到 O(1) 查询

解法二：

参考：http://blog.csdn.net/hyczms/article/details/44339449

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <bitset>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define lson low, mid, _id<<1
#define rson mid+1, high, _id<<1|1

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int, int> Pair;

const ull mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int maxn = 5e4 + 10;

struct Node {
    int key, id, color;
};

Node node[maxn];
int n, cnt, len;
int a[maxn], dp[maxn];
bool vis[maxn];

int cmp_key(Node a, Node b) {
    return a.key < b.key;
}

int cmp_id(Node a, Node b) {
    return a.id < b.id;
}

inline int read();

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    while (scanf("%d", &n) != EOF) {
        for (int i = 1; i <= n; ++i) {
            a[i] = read();
        }
        len = 1, node[1].key = a[1], node[1].id = 1;
        for (int i = 2; i <= n; ++i) {
            if (a[i] != a[i-1]) {
                a[++len] = a[i], node[len].key = a[len], node[len].id = len;
            }
        }
        sort(node+1, node+1+len, cmp_key);
        node[1].color = 1, cnt = 1;
        for (int i = 2; i <= len; ++i) {
            if (node[i].key != node[i-1].key) {
                node[i].color = ++cnt;
            } else {
                node[i].color = cnt;
            }
        }
        sort(node+1, node+1+len, cmp_id);
        memset(vis, false, sizeof(vis));
        vector<int> color;
        dp[0] = 0, dp[len] = len;
        for (int i = 1; i < len; ++i) {
            dp[i] = INF;
        }
        for (int i = 0; i < len; ++i) {
            cnt = 0;
            for (int j = i+1; j <= len; ++j) {
                if (!vis[node[j].color]) {
                    ++cnt, color.push_back(node[j].color), vis[node[j].color] = true;
                }
                if (dp[i] + cnt*cnt >= dp[len]) {
                    break;
                }
                dp[j] = min(dp[j], dp[i]+cnt*cnt);
            }
            for (int j = 0; j < (int)color.size(); ++j) {
                vis[color[j]] = false;
            }
            color.clear();
        }
        printf("%d\n", dp[len]);
    }
    return 0;
}

inline int read()
{
    int ret = 0;
    char c = getchar();
    while (c < '0' || c > '9') {
        c = getchar();
    }
    while ('0' <= c && c <= '9') {
        ret = ret*10 + c - '0';
        c = getchar();
    }
    return ret;
}

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <bitset>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define lson low, mid, _id<<1
#define rson mid+1, high, _id<<1|1

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int, int> Pair;

const ull mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int maxn = 5e4 + 10;

int n, cnt, len;
int a[maxn], dp[maxn], Next[maxn], pre[maxn];

inline int read();

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    while (scanf("%d", &n) != EOF) {
        map<int, int> Map;
        for (int i = 1; i <= n; ++i) {
            a[i] = read();
            pre[i] = i-1, Next[i] = i+1;
        }
        len = 1;
        for (int i = 2; i <= n; ++i) {
            if (a[i] != a[i-1]) {
                a[++len] = a[i];
            }
        }
        for (int i = 0; i <= len; ++i) {
            dp[i] = i;
        }
        pre[0] = -1;
        for (int i = 1; i <= len; ++i) {
            if (Map[a[i]] == 0) {
                Map[a[i]] = i;
            } else {
                int t = Map[a[i]];
                Next[pre[t]] = Next[t], pre[Next[t]] = pre[t];
                Map[a[i]] = i;
            }
            cnt = 0;
            for (int j = pre[i]; j != -1; j = pre[j]) {
                ++cnt;
                dp[i] = min(dp[i], dp[j] + cnt*cnt);
                if (cnt*cnt >= i) {
                    break;
                }
            }
        }
        printf("%d\n", dp[len]);
    }
    return 0;
}

inline int read()
{
    int ret = 0;
    char c = getchar();
    while (c < '0' || c > '9') {
        c = getchar();
    }
    while ('0' <= c && c <= '9') {
        ret = ret*10 + c - '0';
        c = getchar();
    }
    return ret;
}

3、Codeforces 204A  Little Elephant and Interval

题意：

统计区间 [l, r] 内满足第一位和最后一位相等条件的数字

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <bitset>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define lson low, mid, _id<<1
#define rson mid+1, high, _id<<1|1

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int, int> Pair;

const ull mod = 1e9 + 7;
const int INF = 0x7fffffff;

ll l, r, ans = 0;
ll dp[10][20], my_pow[20];
char s[20];

ll get_first(ll x);
ll get(ll x);

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    my_pow[0] = 1;
    for (ll i = 1; i <= 18; ++i) {
        my_pow[i] = my_pow[i-1] * 10;
    }
    memset(dp, 0, sizeof(dp));
    for (ll j = 1; j <= 18; ++j) {
        for (ll i = 1; i <= 9; ++i) {
            if (j == 1) {
                dp[i][j] = dp[i-1][j] + 1;
            } else {
                if (i == 1) {
                    dp[i][j] = dp[9][j-1] + my_pow[j-2];
                } else {
                    dp[i][j] = dp[i-1][j] + my_pow[j-2];
                }
            }
        }
    }
    scanf("%I64d %I64d", &l, &r);
    while (l <= r && get_first(l) != l%10) {
        ++l;
    }
    while (r >= l && get_first(r) != r%10) {
        --r;
    }
    if (l <= r) {
        printf("%I64d\n", get(r) - get(l) + 1);
    } else {
        printf("0\n");
    }
    return 0;
}

ll get_first(ll x)
{
    sprintf(s, "%I64d", x);
    return (ll)(s[0] - '0');
}

ll get(ll x)
{
    sprintf(s, "%I64d", x);
    ll len = (ll)strlen(s);
    ll ret = 0, mid = 0;
    for (ll i = 1; i < len-1; ++i) {
        mid = mid*10 + s[i] - '0';
    }
    ret += mid + 1;
    ll f = get_first(x);
    if (f == 1) {
        ret += dp[9][len-1];
    } else {
        ret += dp[f-1][len];
    }
    return ret;
}

4、Codeforces 479E Riding in a Lift

参考：http://www.cnblogs.com/bhlsheji/p/4821588.html

题意：

有一栋高 n 层的楼，开始你在 a 层，每次会坐电梯到其它楼层

可是这栋楼里有个秘密实验室在 b 层，所以每次你移动的时候就有了一个限制，x 为当前所在层，y 为目标层，|x - y| < |x - b|

问移动 k 次后，有多少不同的路径

解题思路：

dp + 前缀和优化

dp[i][j] 表示第 i 步到达第 j 层有多少种不同的路径，定义 dis = abs(j-b) - 1，那么区间 [max(j-t, 1),  j] 和 [j+1, min(j+t+1, n+1)] 都能被转移

优化的具体做法为：每次要对区间 [low, high] 加上某个值 d 的时候，只要在 low 位置上加上 d，high+1 位置上减去 d 即可，最后每一位置的值即为前缀和

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <bitset>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define lson low, mid, _id<<1
#define rson mid+1, high, _id<<1|1

typedef unsigned int uint;
typedef pair<int, int> Pair;

const int mod = 1e9 + 7;
const int INF = 0x7fffffff;
const int maxn = 5000 + 10;

int n, a, b, k;
int dp[maxn][maxn];

void add(int id, int low, int high, int d);

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    scanf("%d %d %d %d", &n, &a, &b, &k);
    dp[0][a] = 1;
    for (int i = 0; i < k; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (j == b) {
                continue;
            }
            int t = abs(j-b) - 1;
            add(i+1, max(j-t, 1), j, dp[i][j]);
            add(i+1, j+1, min(j+t+1, n+1), dp[i][j]);
        }
        for (int j = 1; j <= n; ++j) {
            dp[i+1][j] = (dp[i+1][j] + dp[i+1][j-1]) % mod;
        }
    }
    int ans = 0;
    for (int i = 1; i <= n; ++i) {
        ans = (ans + dp[k][i]) % mod;
    }
    printf("%d\n", ans);
    return 0;
}

void add(int id, int low, int high, int d)
{
    dp[id][low] = (dp[id][low] + d) % mod;
    dp[id][high] = (dp[id][high] - d) % mod, dp[id][high] = (dp[id][high] + mod) % mod;
}

5、Codeforces 510D Fox And Jumping

参考：http://blog.csdn.net/qq_24451605/article/details/47700563

题意：

给出 n 张卡，每张卡的长度为 li，购买每张卡的花费为 ci，每张卡可以使用无限次，问组成所有自然数的最小花费

解题思路：

显然要求的是购买几张卡且它们长度的 gcd 为 1 的最小花费

可以用 map 存构成某个 gcd 的最小花费

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <bitset>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define lson low, mid, _id<<1
#define rson mid+1, high, _id<<1|1

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int, int> Pair;

const ull mod = 1e9 + 7;
const int INF = 0x7fffffff;
const int maxn = 300 + 10;

int n;
int l[maxn], c[maxn];
map<int, int> dp;

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        scanf("%d", &l[i]);
    }
    for (int i = 0; i < n; ++i) {
        scanf("%d", &c[i]);
    }
    dp[0] = 0;
    map<int, int>::iterator itr;
    for (int i = 0; i < n; ++i) {
        for (itr = dp.begin(); itr != dp.end(); ++itr) {
            int f = itr->first, s = itr->second;
            int gcd = __gcd(f, l[i]), cost = s + c[i];
            if (dp[gcd] != 0 && dp[gcd] < cost) {
                continue;
            }
            dp[gcd] = cost;
        }
    }
    if (dp[1] != 0) {
        printf("%d\n", dp[1]);
    } else {
        printf("-1\n");
    }
    return 0;
}