C++博客-Yuan-随笔分类-Dp

zoj 1039 博弈dp

_Yuan — Thu, 28 Jul 2011 16:43:00 GMT

/*
    博弈游戏
    2到20的数，两个人轮流取
    取数不能取之前已取过数的倍数，或之前取过的两个数的倍数之和
    给出当前的一个合法局面，问先手要赢的策略

    n<=20，比较明显的mask dp
    dp[mask]表示剩下mask表示的数，当前下手是赢还是输

    注意的是，多case，但是只算一次就行了，不用每个case都clear dp[]
    因为知道了当前局面，就能确定之前选了什么数了
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cstring>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<sstream>
#include<ctime>
#include<bitset>
#include<functional>

using namespace std;

char dp[1<<20];

void add(int &forbiden, int &multiple, int x)//forbiden为不能的位，multiple为之前选的那些数的倍数的位
{
    for (int a = x; a <= 20 ; a += x) {
        forbiden |= 1<<a;
        multiple |= 1<<a;
        forbiden |= multiple<<a;
    }
}

bool win(int mask, int forbiden, int multiple, int x)
{
    if (mask == 0) {
        dp[mask] = -1;
        return false;
    }
    if(dp[mask]) {
        return dp[mask] > 0;
    }
    add(forbiden, multiple, x);
    for (int i = 2; i <= 20; i++) {
        if((mask & (1<<i-2)) == 0 || (forbiden&(1<<i)) )continue;
        if (!win(mask ^ (1<<i-2), forbiden, multiple, i) )  {//这里提前退出了，有些子状态并没有算到
            return dp[mask] = 1;
        }
    }
    dp[mask] = -1;
    return 0;
}

int main()
{
#ifndef ONLINE_JUDGE
    //freopen("in","r",stdin);
    //freopen("out","w",stdout);
#endif

    int T, t = 1, n;
    for (scanf("%d", &T); T--; ) {
        printf("Scenario #%d:\n", t++);
        scanf("%d", &n);
        vector<int> vt, have;
        int vi[30] = {0}, mask = 0;
        for (int i = 1,x; i <= n; i++) {
            scanf("%d", &x);
            vt.push_back(x);
            vi[x] = 1;
            mask |= 1<<(x-2);//
        }
        int forbiden = 0, multiple = 0;
        for (int i = 2; i <= 20; i++) {//给出一个数，肯定给出他的所有因子
            if (vi[i] || (forbiden & (1<<i)) ) continue;
            add(forbiden, multiple, i);
        }
    //    fill(dp, dp+mask+1, 0);   不用每次都clear
        /*
            不要搞一次win(mask)
            然后取dp[mask ^ (1<            所以有些dp[mask']没算到，会为0
            不过取win(mask ^ (1<        */
        vector<int> ans;
        for (int i = 0; i < vt.size(); i++) {
            if (!win(mask^(1<<vt[i]-2), forbiden, multiple, vt[i])) {
                ans.push_back(vt[i]);
            }
        }
        if(ans.empty()) {
            puts("There is no winning move.");
        } else {
            printf("The winning moves are:");
            sort(ans.begin(), ans.end());
            for (int i = 0; i < ans.size(); i++) {
                printf(" %d", ans[i]);
            }
            puts(".");
        }
        puts("");
    }
    return 0;
}

_Yuan 2011-07-29 00:43 发表评论

poj 3373 状态的设计

_Yuan — Tue, 26 Jul 2011 13:36:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->/**//* 可改变数字串A的每一位，串A的长度n<=100 求改变出的新串（不能有前缀0），需要是x&l... 阅读全文

_Yuan 2011-07-26 21:36 发表评论

ural 1577 E-mail

_Yuan — Mon, 18 Jul 2011 13:09:00 GMT

/*
    给出两个串A,B <=2000，构造一个新串，使得该新串的子序列是A,B，且长度最短
    求新串的方案数
    显然是最小长度n+m-lcs

    比赛时，我错误做法是对相邻匹配点中间的字符进行排列，如
    abcd
    aefd
    就固定a,d，中间的b,c,e,f排列，当然需要b在c前，e在f前
    但这种做法遇到多个匹配点时就有问题了，如
    be
    babo
    上面的b可以跟下面两个匹配，直接像上面那样子排列会有重复的问题
    当时局限在上面的思路，没搞出.

    其实不难，直接dp即可
    dp[i,j]表示以A[i]或者B[j]结尾的串的个数

    如果A[i] = B[j]，则dp[i,j] = dp[i-1,j-1]   因为这时必须匹配A[i],B[j]
    否则，lcs[i-1,j] > lcs[i,j-1] 则dp[i,j] = dp[i-1,j]   这时新串肯定是A[i]结尾，因为取的是dp[i-1,j]
           lcs[i-1,j] < lcs[i,j-1] 则dp[i,j] = dp[i,j-1]      这时新串肯定是B[i-1]结尾
           lcs[i-1,j] = lcs[i,j-1] 则dp[i,j] = dp[i-1,j] +dp[i,j-1]  这时新串可以是A[i]或B[j]结尾，但不会重复，因为尾部不同

    坑得，当时比赛时，没想打如果取dp[i-1,j]，自然是以A[i]结尾的！！！
    结尾不同，不会导致重复计数的！！
    用组合数学的方法算时，不清楚尾部是什么
*/
#include<cstdio>
#include<iostream>
#include<cmath>
#include<map>
#include<queue>
#include<vector>
#include<bitset>
#include<set>
#include<cstring>
#include<string>
#include<stack>
#include<cassert>
#include<sstream>
#include<list>
#include<algorithm>

using namespace std;

const int INF = 0x3f3f3f3f;
const int MAXN = 2010;
const int MOD = 1000000007;

int dp[MAXN][MAXN], lcs[MAXN][MAXN];
char A[MAXN], B[MAXN];

int main()
{
    //freopen("in","r", stdin);
    //freopen("out","w", stdout);
    while (~scanf("%s%s", A+1, B+1)) {
        int n = strlen(A+1);
        int m = strlen(B+1);
        memset(dp, 0, sizeof dp);
        memset(lcs, 0, sizeof lcs);
        for (int i = 0; i <= n; i++) {
            dp[i][0] = 1;
        }
        for (int i = 0; i <= m; i++) {
            dp[0][i] = 1;
        }
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m;j ++) {
                if (A[i] == B[j]) {
                    lcs[i][j] = lcs[i-1][j-1]+1;
                    dp[i][j] = dp[i-1][j-1];
                } else if (lcs[i-1][j] > lcs[i][j-1]) {
                    lcs[i][j] = lcs[i-1][j];
                    dp[i][j] = dp[i-1][j];
                } else if (lcs[i-1][j] < lcs[i][j-1]) {
                    lcs[i][j] = lcs[i][j-1];
                    dp[i][j] = dp[i][j-1];
                } else {
                    lcs[i][j] = lcs[i-1][j];
                    dp[i][j] = (dp[i-1][j] + dp[i][j-1]) % MOD;
                }
            }
        //cout<
        cout<<dp[n][m]<<endl;
    }
    return 0;
}

_Yuan 2011-07-18 21:09 发表评论

poj 2057

_Yuan — Wed, 22 Jun 2011 17:41:00 GMT

/*
    一棵树n<=1000(节点的分支<=8)，Snail在根处，它要找到在某个叶子处的house
    而其中一些节点上有worm，worm会告诉它的house是否在这个子树上
    求Snail最快寻找到house走过路径的期望值

    哈哈，自己花了2个多钟想出来的
    论文《贪婪的动态规划》有

    首先要弄清楚题目要算的是什么，
        期望E = 某种策略下根到所有叶子的路径长度之和 / 叶子个数

    显然，对于节点u，第一次试探的儿子v会影响后来的路径长度，这需要枚举
    这样枚举第一个儿子v后，问题转化为u对剩下的子树的决策了        ----------OMG
    需要用mask来记录了，  mask <----- v + mask' （即枚举第一个v，剩下的是mask'）

    上面是定性的分析，那精确地定量分析是：
    dp[u,mask]表示如果house在u的子树内，现在考虑的子树是mask时的路径长度之和
    转移就是枚举第一个子树v，分house可能在子树v和不在子树v内（这就是为什么dp[]是表示house在子树u内的）
    house在子树v时：dp[v] + leaf[v]
        leaf[v]为子树v的叶子数目，因为对于v内的每个叶子，都需要先从u走到v，即都要加1
    house不在子树v时： dp[u,mask'] + 经过试探v增加的距离*mleaf[mask']
        mleaf[mask']为mask'叶子数目
        经过试探v增加的距离就要分v是否有worm了
        如果v有worm，worm告诉Snail house不在v之内，显然增加的距离就是2了
        如果v没有worm，就需要继续往v试探，增加的距离inc[v]也容易算出来.

    这道题的启示就是要先弄明白要计算的是什么，知道了这个后才能正确地设计，避免走弯路
    既然是期望，就讨论目标在所有位置的情况                        ----------OMG
    我的速度还是太慢了~~
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>
#include<bitset>

using namespace std;

const int INF = 1000000000;
const int MAXN = 1010;

int dp[MAXN][1<<8], leaf[MAXN], inc[MAXN];
vector<int> e[MAXN];
bool mark[MAXN];

void dfs(int u)
{
    leaf[u] = e[u].empty();
    inc[u] = 0;//noted.
    for (vector<int> ::iterator it = e[u].begin(); it != e[u].end(); it++) {
        int v = *it;
        dfs(v);
        inc[u] += 2 + inc[v];
        leaf[u] += leaf[v];
    }
    if (mark[u]) {
        inc[u] = 0;
    }
    int n = e[u].size();
    fill(dp[u], dp[u] + (1<<n), INF);
    dp[u][0] = 0;
    int mleaf[1<<8] = {0};
    for (int mask = 1, limit = 1<<n; mask < limit ; mask++) {
        for (int j = 0; j < n; j++) {
            if (mask & (1<<j)) {
                int v = e[u][j], nn = e[v].size();
                dp[u][mask] = min(dp[u][mask],
                    dp[v][(1<<nn)-1] + leaf[v] + dp[u][mask^(1<<j)] + (inc[v]+2)*mleaf[mask^(1<<j)]);
                mleaf[mask] += leaf[v];
            }
        }
        //cout<
    }
    //cout<
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    for (int n; scanf("%d", &n), n;) {
        fill(mark+1, mark+1+n, false);
        for (int i = 1; i <= n; i++) {
            e[i].clear();
        }
        int root;
        char ch;
        for (int i = 1, x; i <= n; i++) {
            scanf("%d %c", &x, &ch);
            if (x == -1) {
                root = i;
            } else {
                e[x].push_back(i);
            }
            mark[i] = ch == 'Y';
        }
        dfs(root);
        printf("%.4f\n", (double)dp[root][(1<<e[root].size())-1] / leaf[root]);
    }
    return 0;
}

_Yuan 2011-06-23 01:41 发表评论

CF79D 神奇 bitmask

_Yuan — Fri, 13 May 2011 04:29:00 GMT

摘要: /**//* n<=10000灯，初始Off k<=10个特殊位置x1,,xk需要最后是On l<=100种按法，每次可以按连续长为ai的灯，使之off<->on 求最少的步数 ... 阅读全文

_Yuan 2011-05-13 12:29 发表评论

CF79C

_Yuan — Wed, 04 May 2011 17:10:00 GMT

摘要: /**//* 一个文本串len<=10^5 n<=10个boring串，len<=10 求最长的连续子串，不包含任何一个boring串我之前的做法比较慢 &nbs... 阅读全文

_Yuan 2011-05-05 01:10 发表评论

CF54C

_Yuan — Wed, 04 May 2011 17:06:00 GMT

/*
    区间[L,R]中每个数出现的概率为1/(R-L+1)
    现给出n个区间，[Li,Ri]，每个区间抽取出一个数
    求这n个数中，至少有K%个数的前缀为1的概率

    可以处理出每个区间[Li, Ri]抽取的数前缀为1的概率p[i]
    dp[i,j]表示前面i个区间有j个数前缀为1的概率
    则转移就是dp[i,j] = dp[i-1,j-1]*p[i]  + dp[i-1,j]*(1-p[i])
    答案就是∑dp[n,j]， j/n >= K%
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>
#include<bitset>

using namespace std;

long long cal(long long x) {//[1,x]
    long long cnt = 0 , now = 1;
    while(x/now > 1) {
        cnt += now;
        now *= 10;
    }
    if(x / now == 1) {//x = 1***
        cnt += x - now + 1;
    }
    return cnt;
}

double cal(long long left, long long right) {
    return (cal(right) - cal(left-1)) / (right - left + 1.0);
}

double p[1000], dp[1000][1000];

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    for (int n; ~scanf("%d", &n); ) {
        long long left, right;
        for (int i = 0; i <n ; i++) {
            scanf("%I64d%I64d", &left, &right);
            p[i] = cal(left, right);
        }
        memset(dp, 0, sizeof dp);
        dp[0][0] = 1.0;
        for (int i = 1; i <= n; i++) {
            for(int j = 0; j <= i; j++) {
                dp[i][j] = dp[i-1][j-1]*p[i-1] + dp[i-1][j]*(1-p[i-1]);
            }
        }
        int per;
        scanf("%d", &per);
        double ans = 0;
        for( int j = 0 ; j <= n; j++ ) {
            if(100*j >= n*per) {
                ans += dp[n][j];
            }
        }
        printf("%.10f\n", ans);
    }
    return 0;
}

_Yuan 2011-05-05 01:06 发表评论

CF67F 不用对t排序，不等式隐含

_Yuan — Wed, 04 May 2011 01:24:00 GMT

/*
n个事件，每个在时间ti(ti>=1),发生在坐标xi处，人移动的速度是v
问当时间0时起始位置在0和起始位置任意选时最多能遇到的事件个数
n <= 100000
一开始我按照时间排序，然后就是从后往前dp[i] = max{dp[j]} + 1, tj >= ti && |xi-xj| <= v(tj-ti)
按照时间排后降了一维，能满足tj>=ti，然后将|xi-xj| <= v(tj-ti)拆成xi+vti<=xj+vtj, xi-vti>=xj-vtj
以为能将xi+vti作为线段树的轴，然后插入时是插入xi-vti,和dp[i]，发现会有问题的，
主要是不同到两个事件可能会有相同到xi+vti,这样导致线段树上到一个点有两个值，更新时就不确定更新哪个了
这个处理跟2010福州的一题类似，通过对某个算出来的值排序降掉一维，然后再查找算出的另外一个值
http://www.cppblog.com/Yuan/archive/2010/12/22/137176.html

以上挣扎后还是没Gao出.#_#

看了解题报告，不用对ti排序！！
因为我们是为了满足|xi-xj| <= v(tj-ti)，而满足这个不等式的肯定有tj>=ti，所以不用对ti排序
以上不等式等价于：  xi + vti <= xj + vtj , -xi + vti <= -xj + vtj
令p = xi + vti, q= -xi + vti，按照(p,q)排序，这样就相当于找LIS了，比较的值是q
要用nlogn的LIS

题中的point0是指坐标为0，不是第一个事件的位置，下标是从1开始，显然就不是啦（我一开是以为是..T_T）
还有一个地方就是，求LIS时注意=也是成立的！！！

很不错的一道题吧，我一开始就陷入先对ti排序到困局..
如果能想到满足|xi-xj| <= v(tj-ti)的必满足tj>=ti就不用考虑ti了，转去对p排序
*/
#include<cstdio>
#include<iostream>
#include<map>
#include<algorithm>
#include<vector>
#include<cmath>
#include<cassert>

using namespace std;

const long long INF = 1LL << 60;
const int MAXN = 100086;

struct Event {
    int t, x;
    long long p, q;
    // |xi - xj| <= v(tj-ti)  ,  tj >= ti
    //=> -v(tj-ti)  <= xi - xj <= v(tj-ti)  , don't need to consider tj >= ti . since this inequality implys
    //=>  -xi + vti <= -xj + vtj  , xi + vti <= xj + vtj
    // let p = x + vt  q = -x + vt
    // sort by (p,q)

    void doit(long long v)
    {
        p = x + v*t;
        q = -x + v*t;
    }

    bool operator<(const Event & B)const
    {
        if (p != B.p) {
            return p < B.p;
        }
        return q < B.q;
    }

    bool operator ==(const Event & B) const
    {
        return x == B.x && t == B.t;
    }
};

Event event[MAXN];
int dp[MAXN];

inline bool boundCmp(const int &a, const int &b)
{
    return event[a].q > event[b].q;
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
#endif

    for (int n, v, startX; ~scanf("%d", &n);) {

        for (int i = 0; i < n; i++) {
            scanf("%d%d", &event[i].x, &event[i].t);
        }
        scanf("%d", &v);
        for (int i = 0; i < n; i++) {
            event[i].doit(v);
        }
        sort(event, event + n);

        int ans = 0;
        vector<int> vt;
        for (int i = n - 1; i >= 0; i--) {
            int pos = upper_bound(vt.begin(), vt.end(), i, boundCmp) - vt.begin();
            dp[i] = pos + 1;
            if (pos == vt.size()) {
                vt.push_back(0);
            }
            vt[pos] = i;
            if (abs(0 - event[i].x) <= (long long) v * event[i].t) {
                ans = max(ans, dp[i]);
            }
        }
        cout << ans << " " << *max_element(dp, dp + n) << endl;
    }
    return 0;
}

_Yuan 2011-05-04 09:24 发表评论

CF70E 树dp 要考虑子树外的点

_Yuan — Tue, 03 May 2011 14:05:00 GMT

摘要: /**//* 一棵树n<=180，树上每条边的长度都是1，若两点的距离为len，则他们通信的代价就是d[len] d[]是给出的可以选一些点建立Information Reform，这些点可自动获... 阅读全文

_Yuan 2011-05-03 22:05 发表评论

CF53E 状态压缩两个mask

_Yuan — Tue, 03 May 2011 05:07:00 GMT

/*
    给出一个无向图n<=10，运行删掉一些边，求使得最后是一棵树而且只剩k个叶子的方法数
    知道是状态dp，表示不出来
    看了别人的，原来需要两个mask
    dp[tree,leaf]，tree,leaf均是mask，表示当前整棵树的节点，以及叶子节点       --------------------OMG
    转移是枚举边，扩大tree,leaf，即增加一个叶子（但也有可能把原来是叶子的变为非叶子）

    注意每个状态(tree,leaf)最后要除以叶子leaf的数目，因为扩展这些叶子leaf都得到同样的一棵树tree，即这个tree
    被算了leaf次.
    另外注意的是只有两个节点时，它们都是leaf

    初始化为dp[1<*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>
#include<bitset>

using namespace std;

int dp[1<<10][1<<10];
int bitCount[1<<10];

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    for (int mask = 1; mask < (1<<10); mask++) {
        bitCount[mask] = bitCount[mask>>1] + (mask&1);
    }

    for (int n, m, k; ~scanf("%d%d%d", &n, &m, &k); ) {
        vector<pair<int,int> > edge;
        int u, v;
        for (int i = 0; i < m ; i ++) {
            scanf("%d%d", &u, &v);
            u--;
            v--;
            edge.push_back(make_pair(u,v));
            edge.push_back(make_pair(v,u));
        }
        int limit = 1<<n;
        fill(dp[0], dp[limit] , 0);
        for (int i = 0; i < n; i++) {
            dp[1<<i][1<<i] = 1;//leaf
        }
        for (int tree = 1; tree < limit ; tree++) {
            for (int leaf = 1; leaf < limit ; leaf ++) {
                if(dp[tree][leaf] != 0) {
                    dp[tree][leaf] /= bitCount[leaf];
                    for ( vector<pair<int,int> >::iterator it = edge.begin(); it != edge.end(); it++) {
                        u = it->first;
                        v = it->second;
                        if((tree & (1<<v)) || !(tree&(1<<u))){
                            continue;
                        }
                        int _tree = tree | (1<<v);
                        int _leaf = leaf | (1<<v);
                        if((_leaf & (1<<u)) && bitCount[_tree] != 2) {
                            _leaf ^= (1<<u);
                        }
                        dp[_tree][_leaf] += dp[tree][leaf];
                    }
                }
            }
        }
        int ans = 0;
        for (int leaf = 1; leaf < limit ; leaf ++) {
            if(bitCount[leaf] == k) {
                ans += dp[limit-1][leaf];
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

_Yuan 2011-05-03 13:07 发表评论

CF67D 排列图的最大团即LIS

_Yuan — Mon, 02 May 2011 16:42:00 GMT

/*
    给出如图的电路布线，求最大的一块，其中里面的线两两相交
    n<=10^6

    看解题报告的：
    http://itbhu.ac.in/codefest/problem.php?pid=102
    它说这是一个Permutation Graph
    先将上面那排的数字映射为1,2,,n，然后下面那排再映射一下
    其中的最大图就是最长下降子序列了     -------------------------------OMG
    O(nlogn)
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>
#include<bitset>

using namespace std;

const int MAXN = 1000010;

int a[MAXN];

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

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    ios::sync_with_stdio(false);//取消跟stdin的同步  然后cin,cout就不要跟scanf,printf混用了
    for (int n ; cin>>n ; ) {
        for (int i = 1, x ; i <= n ; i++) {
            cin>>x;
            a[x] = i;//
        }
        vector<int> rec;
        for (int i = 1, x; i <= n ; i ++) {
            cin>>x;
            x = a[x];//
            int pos = upper_bound(rec.begin(), rec.end(), x, cmp) - rec.begin();
            if(pos == rec.size()){
                rec.push_back(0);
            }
            rec[pos] = x;
        }
        cout<<rec.size()<<endl;
    }
    return 0;
}

_Yuan 2011-05-03 00:42 发表评论

67C 编辑距离变形允许交换相邻

_Yuan — Mon, 02 May 2011 06:30:00 GMT

/*
    问将串A变到串B的最小时间，不过多了一种方法就是交换相邻
    插入、删除、替换、交换的时间为ti,td,tr,te
    不过题目给出了2te>=ti+td

    一开始不会做，看了解题报告提到Damerau Levenshtein distance
    http://www.itbhu.ac.in/codefest/problem.php?pid=101
    Wiki上有Damerau Levenshtein distance
    看了bobchennan的代码

    由于2te>=ti+td，所以A的第i个字母不会跟前面的交换2次，最多只有1次！！！！！！
    有了这个之后，就用la[26],lb[26]记录在状态(i,j)之前，A,B串中各种字母的位置
    “交换”的这种转移就是多寻找一个ii,jj，其中A[ii] == B[j] && A[i] == B[jj]
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>
#include<bitset>

using namespace std;

const int MAXN = 5000;
const int INF = 0x3f3f3f3f;

char A[MAXN], B[MAXN];
int dp[MAXN][MAXN];
int la[26],lb[26];

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    for(int ti, td, tr, te; cin>>ti>>td>>tr>>te; ) {
        scanf("%s%s", A+1, B+1);
        int lenA = strlen(A+1), lenB = strlen(B+1);
        dp[0][0] = 0;
        for (int i = 1; i <= lenA ; i++){
            dp[i][0] = td*i;
        }
        for ( int j = 1 ; j <= lenB ; j++) {
            dp[0][j] = ti*j;
        }
        fill(la,la+26,0);
        for (int i = 1; i <= lenA ; i++) {
            fill(lb,lb+26,0);
            for(int j = 1; j <= lenB ; j ++) {
                dp[i][j] = INF;
                dp[i][j] = min(dp[i][j], dp[i-1][j-1] + tr*(A[i] != B[j]));
                dp[i][j] = min(dp[i][j], dp[i-1][j] + td);
                dp[i][j] = min(dp[i][j], dp[i][j-1] + ti);
                int ii = la[B[j]-'a'], jj = lb[A[i]-'a'];
                if(ii > 0 && jj > 0){
                    dp[i][j] = min(dp[i][j], dp[ii-1][jj-1] + te + (i-ii-1)*td + (j-jj-1)*ti);//swap(ii,i)
                }
                lb[B[j]-'a'] = j;
            }
            la[A[i]-'a'] = i;
        }
        printf("%d\n", dp[lenA][lenB]);
    }
    return 0;
}

_Yuan 2011-05-02 14:30 发表评论

zoj 3493 概率、期望枚举子集再枚举子集注意inf,nan

_Yuan — Sat, 23 Apr 2011 02:40:00 GMT

摘要: /**//* 要从n<=13个人中通过黑白配多去少留（相等的话继续），如果只有两个人则剪刀石头布来选出一个苦力。要求选出苦力所用时间的期望，还有哪些人最有可能成为苦力，及其成为苦力的概率。给出每个人出黑、白、石头、剪刀、布的... 阅读全文

_Yuan 2011-04-23 10:40 发表评论

zoj 3494 先ac自动机预处理一下 dfa 数位统计

_Yuan — Thu, 21 Apr 2011 13:46:00 GMT

摘要: /**//* 问A到B之间的所有整数，转换成BCD Code后，有多少个不包含属于给定非法01串集合的子串。 0 < A ≤ B < 10^200 统计问题... 阅读全文

_Yuan 2011-04-21 21:46 发表评论

09 武汉 H题 help bubu 复杂dp

_Yuan — Sun, 27 Mar 2011 02:28:00 GMT

摘要: /**//* 09年武汉赛的H题 help bubu n本书，每本的高度在[25,32] 可以有m次抽出书的机会，然后再放回去最后，高度相同的连续... 阅读全文

_Yuan 2011-03-27 10:28 发表评论

noi 2004 小H的小屋八中1505 从上次的k开始枚举，降维

_Yuan — Thu, 24 Mar 2011 12:37:00 GMT

/*
    如图，两条斜线，斜率分别为mk,nk
    先要对[0,100]划分，上面的分m个，下面的分n个，m<=n <=100
    要求上面划分的点下面也有，点均是整点
    求各矩形面积之和最小

    dp[m,n,x] 表示[0,x]上面划分了m个，下面划分了n个最优值
    转移是枚举上面的最后一块的长度，以及划分了多少个小块
    dp[m,n,x] = min{dp[m-1,n-k,x-len] + cost[k,len]}
    cost[k,len]表示长度为len，分为k小块的最小代价，可预处理处理

    朴素的话要 100^5，超时
    我搞了一下午打算用斜率优化搞
    这里转移跟两个变量有关系，搞不出T_T

    这题杨戈论文《从<小H的小屋>的解法谈算法的优化》里有
    在确定了len，枚举k时，
    dp[m-1,n-k,x-len] + cost[k,len]是一个抛物线，
    而当len增大时，也是一个抛物线，而且最低点的k'不会比之前的k小
    这样，记录上次枚举到的k，下次从这里开始，不回溯
    降了一维

    但我还不是很懂@_@
    为什么会是抛物线，以及最低点k不会比之前k的小  ????

    那篇文章还提到贪心算法的
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>

using namespace std;

#define sqr(x) ((x)*(x))

double dp[2][101][101], cost[101][101];

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
    //freopen("out","w",stdout);
#endif

    double mk, nk;
    int M,N;
    for (; ~scanf("%lf%lf%d%d", &mk, &nk, &M, &N);) {

        fill(cost[0], cost[1], 1e20);
        cost[0][0] = 0.0;

        for(int i = 1; i <= N; i++){//貌似这个用斜率优化，效果不大，比起下面的循环，小得多
            for(int j = i; j <= 100; j++){
                cost[i][j] = 1e20;
                for(int k = j - 1 ; k >= i-1; k-- ){
                    cost[i][j] = min(cost[i][j], cost[i-1][k] + sqr(j-k)*nk);
                }
            }
        }

        for (int i = 1 ; i <= N; i ++) {
            for (int j = 1; j <= 100; j ++) {
                cost[i][j] += sqr(j)*mk;
            }
        }

        int now = 0, pre = 1;
        fill(dp[0][0], dp[1][0], 1e20);
        dp[0][0][0] = 0.0;

        for (int m = 1; m <= M; m++) {
            swap(now, pre);
            fill(dp[now][0], dp[now+1][0], 1e20);//注意要对无效状态赋初值！！
            for (int n = m; n <= N; n++) {
                for(int x = n; x <= 100; x++){
                    for(int len = 1, last = 1; x - len >= m - 1; len++){
                        for(int k = 1; k <= len && n - k >= m-1; k++){//从上次最优位置开始 k = last
                            if(dp[pre][n-k][x-len] + cost[k][len] < dp[now][n][x]){
                                dp[now][n][x] = dp[pre][n-k][x-len] + cost[k][len];
                                last = k;
                            }
                        }
                    }
                }
            }
        }

        printf("%.1f\n", dp[now][N][100]);
    }
    return 0;
}

_Yuan 2011-03-24 20:37 发表评论

noip2007 特种部队转移是枚举哪一个去接max(i,j)+1

_Yuan — Thu, 24 Mar 2011 02:15:00 GMT

/*

    一排按钮，要求从第一个，按到最后一个，再从最后一个按回来
    中间可以跳着按，但要求每个按钮有且按一次，求使得相邻按的按钮的分数差之和最小
    给出n<=1000个数

    参考
    http://hi.baidu.com/xiszishu/blog/item/650f5b8e094b07fef11f3667.html

    双进程dp   双调tsp
    由于最后不会按回1，所以加多一个0按钮，到各个按钮的差异为0
    dp[i,j] i < j
    表示从一个从0按到i,一个从0按到j的最小代价
    转移是枚举i,j哪个下一步按max(i,j)+1   （扩展一步去转移丫，我就不会这个转移了！！！）
    dp[i,k] = max(dp[i,k] + dp[i,j] + abs(a[j]-a[k]))
    dp[k,j] = max(dp[k,j] + dp[i,j] + abs(a[i]-a[k]))
    答案就是dp[n-1,n] + abs(a[n-1]-a[n])

*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>

using namespace std;

const int MAXN = 1010;
const int INF = 1000000000;

int a[MAXN];
int dp[MAXN][MAXN];

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    for(int n; ~scanf("%d", &n); ){
        for(int i = 1 ; i <= n ; i++){
            scanf("%d", &a[i]);
        }
        fill(dp[0], dp[MAXN], INF);
        dp[0][0] = 0;
        for(int i = 0; i < n; i++){
            for(int j = i; j < n ; j++){//j = i  因为从[0,0]开始
                if(dp[i][j] >= INF){
                    continue;
                }
                int k = j + 1;
                dp[i][k] = min(dp[i][k], dp[i][j] + (j == 0 ? 0 : abs(a[j] - a[k])) );
                dp[j][k] = min(dp[j][k] , dp[i][j] + (i == 0 ? 0 : abs(a[i] - a[k])));
            }
        }
        printf("%d\n", dp[n-1][n] + abs(a[n]-a[n-1]));
    }
    return 0;
}

_Yuan 2011-03-24 10:15 发表评论

SCU 3903 cowlpha

_Yuan — Fri, 18 Mar 2011 12:08:00 GMT

/*
    目标串是有U个大写字母，L个小写字母
    给出P个合法的字母对(a,b)
    表示目标串相邻的字母必满足这些字母对，不能由其他组成
    问有多少种可能的目标串
    U,L <= 250
    P <= 200

    我比较土，总共52个字母，建立52个点的图
    状态是(pos, u, l) 在点pos处，还剩下u个大写，l个小写的总数

    其实O(ULP)的dp即可   （我之前也有想过的，但是转移我居然是枚举字母来转移52*52，然后就放弃了）
    转移应该是枚举字母对！！！总共P个

*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>

using namespace std;

const int MOD = 97654321;

char validPair[201][3];
int dp[251][251][52];

inline int get(char ch){
    return isupper(ch) ? 26+ch-'A' : ch-'a';
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    for(int U, L, P; ~scanf("%d%d%d", &U, &L, &P); ){
        for(int i = 0 ; i < P ; i++){
            scanf("%s", validPair[i]);
            //先get完，后面在计算时就不用再次get快很多
            validPair[i][0] = get(validPair[i][0]);
            validPair[i][1] = get(validPair[i][1]);
        }
        memset(dp, 0, sizeof dp);
        for(int j = 0 ; j < 52 ; j++){
            dp[(j>=26)][(j<26)][j] = 1;
        }
        for(int u = 0 ; u <= U ; u ++){
            for(int l = 0; l <= L ; l++){
                if(u+l <= 1){
                    continue;
                }
                for(int i = 0; i < P ; i++){
                    int first = validPair[i][0];
                    int second = validPair[i][1];
                    if(second < 26 && l > 0){
                        dp[u][l][second] += dp[u][l-1][first];
                        dp[u][l][second] %= MOD;
                    }
                    if(second >= 26 && u > 0){
                        dp[u][l][second] += dp[u-1][l][first];
                        dp[u][l][second] %= MOD;
                    }

                }
            }
        }
        printf("%lld\n", accumulate(dp[U][L], dp[U][L]+52, 0LL) % MOD);
    }
    return 0;
}

_Yuan 2011-03-18 20:08 发表评论

poj 3020

_Yuan — Fri, 04 Mar 2011 01:07:00 GMT

/*
    40*10的地图，有一些'*'必须用方块覆盖到
    而每块方块只能覆盖长度为1*2
    问最少需要的方块数

    状态压缩dp，主要就是枚举当前行的状态to，上一行的状态from,由from的值去更新to的值

    骨牌覆盖类求方案数的，一般都需要枚举所有情况，即放、不放
    但这种求最优值的，我一开始枚举所有情况，导致超时!!
    需要人肉优化
    比如，这里空的位置肯定不用放东西，直接下一列

    这道题，转移时只需考虑当前row和上一行row-1，
    对于列col 分4种情况，
    00 01 10 11
    1表示该位置是'*'
    分这4种情况：
    ①不放状态构造为 to<<1 , from<<1
    ②上一行有'*'  状态构造为 to<<1 , from<<1|1
    ③当前行有'*'  由于上一行没有，就没必要竖放了，直接横放了，竖放不会导致最优解
       然后还要考察col+1是否有'*'，有的话状态要加上去
       当然，该位置可以不放，为了给下一行覆盖
    ④上下行都有'*'
       不放的话，上一行就需要有覆盖了
       横放，上一行肯定就要被覆盖了
       竖放，上一行可选择被覆盖，或者没被覆盖
       但选择被覆盖是不会导致最优解的，因为横放的时候就会考虑上一行该位置要被覆盖了


    求最优值（不是求方案），没必要转移时 from -> to 把一些明显不优的状态from转移到to去
    如对于'O'位置，可以放，但肯定不去放它，放了不会更优的，所以不进入这个分支了
    分支数决定了规模，人肉优化，不进入没必要的分支
    但求方案数目的话，就要考虑所有情况了，放、不放之类的
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>

using namespace std;

const int INF = 1000000000;

char field[50][20];
int dp[50][1<<10];
int H, W;

void dfs(int row, int col , int s1 , int s2 , int num){//当前检查col
    /*if(col > W){
        return;
    }*/
    if(col >=  W){//因为可能在最后一列水平覆盖，所以出格了
        if(col>W){//注意>>
            s1 >>= 1;
            s2 >>= 1;
        }
        dp[row][s1] = min(dp[row][s1] , dp[row-1][s2] + num);
        return;
    }
    int code = (field[row][col] == '*')*2 + (field[row-1][col] == '*');

    switch(code){
        case 0:
            dfs(row, col+1, s1<<1, s2<<1, num);
            break;
        case 1:
            dfs(row, col+1, s1<<1, s2<<1|1, num);//用|去覆盖(row-1,col)跟(row-1,col)自己覆盖效果一样
            break;
        case 2:
            dfs(row, col+2, (s1<<2)|2|(field[row][col+1] == '*'), (s2<<2)|(field[row-1][col+1] == '*'), num+1);
            //nothing
            dfs(row, col+1, s1<<1, s2<<1, num);
            break;
        case 3:
            //nothing
            dfs(row, col+1, s1<<1, s2<<1|1, num);
            dfs(row, col+1, s1<<1|1, s2<<1, num+1);
            //dfs(row, col+1, s1<<1|1, s2<<1|1, num+1);  s2<<1|1在下面的状态会考虑到的，而且下面的不会比它差所以不用再dfs
            dfs(row, col+2, (s1<<2)|2|(field[row][col+1] == '*'), (s2<<2)|2|(field[row-1][col+1] == '*'), num+1);
            break;
    }
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    int T;
    for(scanf("%d",&T); T-- ;){
        scanf("%d%d",&H,&W);
        for(int i = 1 ; i <= H; i++){
            scanf("%s",field[i]);
        }
        for(int row = 1 ; row <= H ; row++){
            fill(dp[row] , dp[row] + (1<<W), INF);
            dfs(row,0,0,0,0);
        }
        int ans = INF;
        int mask = 0;
        for(int i = 0; i < W ; i++){
            mask <<= 1;
            mask |= (field[H][i] == '*');
        }
        for(; mask < (1<<W);mask++){
            ans = min(ans, dp[H][mask]);
        }
        printf("%d\n",ans);
    }
    return 0;
}

_Yuan 2011-03-04 09:07 发表评论

Poj 2904 理解题意博弈的意味

_Yuan — Thu, 03 Mar 2011 04:50:00 GMT

/*
    一个邮筒理论上能承受的最大爆破值为m，则实际在范围[1,m]
    现在要测试它的实际爆破值

    如果只有一个邮筒的话，就需要从小到大测试直到破
    最坏情况下，到最后才破
    那就需要测试1,2,,m 总共需要(m+1)*m/2数量的火药了
    注：上一次测试没爆的话，邮筒还是完好的

    但如果有多个邮筒，则可以不用测试那么多次
    如2个的话，第一次测试t ，1<=t<=m
    爆：下次就要测试[1,t-1] 只剩下一个邮筒，
    不爆：继续用当前的邮筒，测试[t+1,m]

    所以dp[k,i,j]表示还剩下k个邮筒，爆破值的范围在[i,j]，为测出爆破值至少需要的火药
    枚举t，则可以由dp[k-1,i,t-1],dp[k,t+1,j]转移过来
    由于事先不知道，为了使火药足够，所以只能取最大值 max(dp[k-1,i,t-1],dp[k,t+1,j])
    但为了最少的测试，所以枚举t，得到最少需要的火药
    dp[k,i,j] = min{t+max(dp[k-1,i,t-1],dp[k,t+1,j])}

    参考
    http://hi.baidu.com/accplaystation/blog/item/c78b13522de9300d0df3e328.html
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>

using namespace std;

const int INF = 1000000000;

int dp[11][101][101];

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    for(int i = 1 ; i <= 100 ; i ++){
        for(int j = i ; j <= 100 ;j++){
            dp[1][i][j] = (j-i+1)*(j+i)/2;
        }
    }
    for(int k = 2 ; k <= 10 ; k++){
        for(int j = 100 ; j > 0 ; j--){
            for(int i = j;  i > 0 ; i--){//dp[k,j,j] = j
                dp[k][i][j] = INF;
                for(int  t = i; t <= j ; t++){
                    dp[k][i][j] = min(dp[k][i][j] , t + max(dp[k][t+1][j] , dp[k-1][i][t-1]));
                }
            }
        }
    }

    int T;
    for(scanf("%d",&T); T-- ;){
        int k , m;
        scanf("%d%d",&k,&m);
        printf("%d\n",dp[k][1][m]);
    }

    return 0;
}

_Yuan 2011-03-03 12:50 发表评论

zoj 3469 代价提前计算一部分 ★★★

_Yuan — Tue, 15 Feb 2011 15:11:00 GMT

/*
    一条直线上，一家餐厅在X，n个客人，第i个在xi
    一个服务员的速度为1/v , 客人i的不满意度为等待时间Ti*Bi
    求 minimal ∑不满意度

    容易知道最优的路线是左右来回走，一直到所有客人都访问完
    设X左边有nl个，右边有nr个
    dp[l,r,0/1]表示[l,r]已经访问完了，目前在左、右边的最优值
    转移时枚举邻近的一个
    如dp[l,r,0] 由dp[l-1,r,0],dp[l-1,r,1]  因为l是由邻近的l-1走过来的！！

    若dp[l,r,0]存的仅仅是[l,r]的代价的话，转移就不知道怎么算了
    因为从[l-1,r]转移到[l,r,0]时，不知道到l的总时间，而dp值又没有存时间
    我困惑在dp应该存题目定义的花费？还是时间？还是两者都存？

    看了watashi的做法
    dp[l,r]的值存的不仅是[l,r]的代价，还包括这段时间内[l,r]之外的点应该计算的代价！！！
    这样子总的代价就能算了
    代价放到前面去计算，应该用得比较多吧？
    poj 1180也是代价放到前面算好一部分

*/

#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<functional>

using namespace std;

const int INF = 1000000000;

vector<pair<int,int> > vl , vr;
int dp[1010][1010][2];

int memo(int l , int r , int p){
    if(dp[l][r][p] == -1){
        int &ans = dp[l][r][p];
        ans = INF;
        if(p==0){
            if(l){
                int sumCost = (vl[l].second+vr[r+1].second);//还包括[l,r]外面的代价值，预先累计
                ans = min(ans , memo(l-1,r,0) + (vl[l-1].first - vl[l].first)*sumCost);
                ans = min(ans , memo(l-1,r,1) + (vr[r].first - vl[l].first)*sumCost);
            }
        }
        else{
            if(r){
                int sumCost = (vl[l+1].second+vr[r].second);
                ans = min(ans , memo(l,r-1,0) + (vr[r].first - vl[l].first)*sumCost);
                ans = min(ans , memo(l,r-1,1) + (vr[r].first - vr[r-1].first)*sumCost);
            }
        }
    }
    return dp[l][r][p];
}

int main()
{
    for(int n , v , x ; ~scanf("%d%d%d",&n,&v,&x);){//题目的v不是速度，是速度的倒数
        vl.clear();
        vr.clear();
        for(int i = 0,xi,bi; i < n ; i ++){
            scanf("%d%d",&xi,&bi);
            if(xi<x){
                vl.push_back(make_pair(xi-x,bi));
            }
            else {
                vr.push_back(make_pair(xi-x,bi));
            }
        }
        vl.push_back(make_pair(0,0));
        vr.push_back(make_pair(0,0));
        sort(vl.begin(),vl.end(),greater<pair<int,int> >() );
        sort(vr.begin(),vr.end());
        int nl = vl.size() - 1;
        int nr = vr.size() - 1;
        for(int i = nl - 1 ; i > 0 ; i--){//vl[i]存的是[i,nl]的值
            vl[i].second += vl[i+1].second;
        }
        vl.push_back(make_pair(-INF,0));
        for(int i = nr - 1 ; i > 0 ; i --){//vr[i]存的是[i,nr]的值
            vr[i].second +=  vr[i+1].second;
        }
        vr.push_back(make_pair(INF,0));
        for(int i = 0 ; i <= nl ; i++)
            for(int j = 0 ; j <= nr; j++)
                dp[i][j][0] = dp[i][j][1] = -1;
        dp[0][0][0] = dp[0][0][1] = 0;
        printf("%d\n",v*min(memo(nl,nr,0),memo(nl,nr,1)));
    }
    return 0;
}

_Yuan 2011-02-15 23:11 发表评论

POJ 3375 线路布线但需要去除冗余 ★★★★

_Yuan — Mon, 23 Aug 2010 11:31:00 GMT

/*
    题意:在M个数中来匹配另外N个，权为|x-y|  问最小代价  M<10^5 N<2000
    先排序，对于最后的匹配结果，不会出现交叉的情况就可以做DP了
    dp[i,j] = min(dp[i,j-1],dp[i-1,j-1]+|x-y|);
    这样子是O(NM)的，会TLE
    对于最优的情况，与Bi匹配的Aj 肯定不会有|ii-j|>N的    ii为A[]中最接近Bi的
    所以对每个Bi 找到最接近Bi的Aj 然后只计算它左右各N个

    这样确定了计算范围的，要注意从i-1过渡到i时取值时(dp[i-1])不要越出范围[beg,end]
*/
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

int dp[2][100005];
int A[100005],B[2010];

int main()
{
    //freopen("in","r",stdin);
    for(int N,M;~scanf("%d%d",&M,&N);)
    {
        for(int i=0;i<M;i++)
            scanf("%d",&A[i]);
        for(int i=0;i<N;i++)
            scanf("%d",&B[i]);

        sort(A,A+M);
        sort(B,B+N);

        int pos=0;
        int beg,end,lbeg=0,lend=0;
        int pre=1,now=0;
        dp[pre][0]=0;

        for(int i=0;i<N;i++)
        {
            while(pos<M&&A[pos]<=B[i])pos++;
            pos--;
            beg=max(i,pos-N);
            end=min(pos+N,M-1);
            int jj=min(beg-1,lend);
            jj=max(jj,lbeg);//也不能小于beg
            dp[now][beg]=dp[pre][jj]+abs(A[beg]-B[i]);
            //printf("%d ",dp[now][beg]);
            for(int j=beg+1;j<=end;j++)
            {
                int jj=min(j-1,lend);
                dp[now][j]=min(dp[now][j-1],dp[pre][jj]+abs(A[j]-B[i]));
                //printf("%d ",dp[now][j]);
            }
            //puts("");
            lbeg=beg;
            lend=end;
            swap(pre,now);
        }
        printf("%d\n",dp[pre][lend]);
    }
    return 0;
}

_Yuan 2010-08-23 19:31 发表评论

hdu 3366 dp算期望，但重点是确定了最优的访问顺序

_Yuan — Sun, 02 May 2010 04:10:00 GMT

/*
    如果已经知道走这些passage的顺序的话，应该可以dp出来的
    但是这里不确定顺序，要选择最优，可以按照P/Q从大到小排序
    遇到匪徒几率Q越小，出去几率P越大，肯定是我们优先考虑的！
    Help Bill to find out the probability that he can escape from this castle if he chose the optimal strategy.

    dp[i][j]表示现在有钱j，在i个passage处，最后能够出去的概率
    dp[n-1,j]=P[n-1]
    dp[i,j]=P[i]+Q[i]*dp[i+1,j-1]+(1-P[i]-Q[i])*dp[i+1,j]   j>0
    dp[i,j]=P[i]+(1-P[i]-Q[i])*dp[i+1,j]   j=0

    概率题期望题，一般都是表示现在离目标的值
    （因为当前接下来的方案确定了，概率也知道了，而当前从前面过来就不确定概率了，其概率跟路径有关）
*/
#include<cstdio>
#include<algorithm>
using namespace std;

struct Pas
{
    double p,q;
    bool operator<(const Pas&B)const
    {
        return p/q>B.p/B.q;
    }
}pas[1010];

double dp[1010][11];

int main()
{
    int n,m,T,t=1;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;i++)
            scanf("%lf%lf",&pas[i].p,&pas[i].q);
        sort(pas,pas+n);
        //mesmet(dp,0,sizeof(dp));
        for(int j=0;j<=m;j++)dp[n-1][j]=pas[n-1].p;
        for(int i=n-2;i>=0;i--)
        {
            dp[i][0]=pas[i].p+(1-pas[i].p-pas[i].q)*dp[i+1][0];
            for(int j=1;j<=m;j++)
            {
                dp[i][j]=pas[i].p+pas[i].q*dp[i+1][j-1]+(1-pas[i].p-pas[i].q)*dp[i+1][j];
            }
        }
        printf("Case %d: %.5f\n",t++,dp[0][m]);
    }
    return 0;
}

_Yuan 2010-05-02 12:10 发表评论

Poj 3345 tree dp +背包但不要算重复

_Yuan — Wed, 28 Apr 2010 03:43:00 GMT

/*
    Note that no country is under domination of more than one country, and the domination relationship makes no cycle.
    给出一棵树，每个点有代价，选了父亲就能选中所有儿子，求最小的代价选中至少m个以上的点
    直接tree dp +背包
    但是注意不要重复算！选了父亲就相当于所有儿子都选了，就不能在这个基础上枚举儿子来更新！
*/
#include<cstdio>
#include<cstring>
#include<string>
#include<vector>
#include <sstream>
#include<algorithm>
#include<map>
using namespace std;

const int MAXN=210;
const int INF=1000000000;

vector<int>G[MAXN];
int dp[MAXN][MAXN];
int cost[MAXN],in[MAXN];
bool vi[MAXN];
int n,m;

int dfs(int u){
    vi[u]=1;
    int num=1;
    for(int i=0;i<G[u].size();i++){
        int v=G[u][i];
        if(vi[v])continue;
        num+=dfs(v);
    }
    for(int j=0;j<=n;j++)dp[u][j]=INF;
    dp[u][0]=0;
    for(int i=0;i<G[u].size();i++){
        int v=G[u][i];
        for(int j=n;j;j--){
            for(int k=1;j-k>=0;k++)
                if(dp[u][j]>dp[u][j-k]+dp[v][k])
                    dp[u][j]=dp[u][j-k]+dp[v][k];
        }
    }
    //不要放在上面，因为num包括了所有儿子节点，然后还更新的话，就是重复了！
    if(dp[u][num]>cost[u])dp[u][num]=cost[u];
    return num;
}
int main(){
    char str[1000];
    while(gets(str)){
        if(str[0]=='#')break;
        sscanf(str,"%d%d",&n,&m);
        for(int i=0;i<=n;i++)G[i].clear();
        map<string,int>Map;
        memset(in,0,sizeof(in));
        int ID=0;
        for(int i=1;i<=n;i++){
            scanf("%s",str);
            if(Map.find(str)==Map.end())Map[str]=++ID;
            int u=Map[str];
            scanf("%d",&cost[u]);
            //while(getchar()==' '){//因为只有空格！
            //    scanf("%s",str);
            //    if(Map.find(str)==Map.end())Map[str]=++ID;
            //    G[u].push_back(Map[str]);
            //    in[Map[str]]++;
            //}
            gets(str);
            stringstream ss(str);
            string name;
            while(ss>>name){
                if(Map.find(name)==Map.end())Map[name]=++ID;
                G[u].push_back(Map[name]);
                in[Map[name]]++;
            }
        }
        cost[0]=INF;
        for(int i=1;i<=n;i++){
            if(in[i])continue;
            G[0].push_back(i);
        }
        memset(vi,0,sizeof(vi));
        dfs(0);
        int ans=INF;
        for(int j=m;j<=n;j++)
            if(dp[0][j]!=-1&&dp[0][j]<ans)ans=dp[0][j];
        printf("%d\n",ans);
    }
    return 0;
}

_Yuan 2010-04-28 11:43 发表评论

hdu 1011 tree dp+背包有trick

_Yuan — Tue, 27 Apr 2010 12:54:00 GMT

刚开始我以为是比较熟悉的树形dp+背包，但一直wa,网上的代码是非递归的，看到我头晕，看了大牛的代码后才发现有Trick...
发下代码，给有同样问题的人参考下

/*
    题意：给出一棵树，每个点有权值，要取得这个权值需要代价，通过父亲后才能到达儿子
    问能量有限时获得的最大值
    直接tree dp+背包
    注意的是，每个点至少要有一个人，即使没有bug！
*/
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;

const int MAXN=110;
const int INF=1000000000;

int n,m;
vector<int>G[MAXN];
int bug[MAXN],brain[MAXN];
bool vi[MAXN];
int dp[MAXN][MAXN];

void dfs(int u){
    vi[u]=1;
    for(int j=1;j<=m;j++)dp[u][j]=-INF;
    dp[u][0]=0;
    int t=(bug[u]+19)/20;
    //if(!t&&brain[u])t=1; 这样写会错
    /*
        2 1
        0 1
        0 1
        1 2
        答案是2
        上面那样写答案是1
    */
    if(t<=m)dp[u][t]=brain[u];
    for(int i=0;i<G[u].size();i++){
        int v=G[u][i];
        if(vi[v])continue;
        dfs(v);
        for(int j=m;j>t;j--)
            for(int k=1;j-k>=t;k++)
                if(dp[u][j-k]!=-1&&dp[v][k]!=-1&&dp[u][j]<dp[u][j-k]+dp[v][k])
                    dp[u][j]=dp[u][j-k]+dp[v][k];
    }
    //一定要有这一句，占领父亲取得brain，至少要有一个人！
    //虽然不用攻击bug，所以这个人可以用来访问儿子
    //不需要人就能获得brain,显然不行
    if(dp[u][0]>0){
        dp[u][1]=max(dp[u][1],dp[u][0]);
        dp[u][0]=0;
    }
}

int main(){
    int a,b;
    while(scanf("%d%d",&n,&m),n!=-1){
        for(int i=1;i<=n;i++){
            scanf("%d%d",&bug[i],&brain[i]);
            G[i].clear();
        }
        for(int i=1;i<n;i++){
            scanf("%d%d",&a,&b);
            G[a].push_back(b);
            G[b].push_back(a);
        }
        memset(vi,0,sizeof(vi));
        dfs(1);
        int ans=0;
        for(int j=1;j<=m;j++)
            ans=max(ans,dp[1][j]);
        printf("%d\n",ans);
    }
    return 0;
}

_Yuan 2010-04-27 20:54 发表评论

Poj 2923 二进制枚举可放的状态，01背包

_Yuan — Mon, 12 Apr 2010 01:45:00 GMT

/*
   http://hi.baidu.com/forverlin1204/blog/item/96eeab102a2a6dcda6ef3f61.html
    状态压缩DP
    给定两辆车的容量c1,c2,物品的个数n，每件物品的重量w[i]，要使来回趟数尽可能少
    枚举1<    state存储可以一次由两辆车运完的状态
*/
#include<cstdio>
#include<cstring>

int n,c1,c2;
int w[12],v[12];
int dp[1<<11];
int state[1<<11],tot;

//选中k个，再用2进制组合
void comb(){
    int limit=1<<n;
    tot=0;
    for(int i=1;i<limit;i++){
        int k=0;
        for(int t=0;t<n;t++)if(i&(1<<t))v[k++]=w[t];
        int klimit=1<<k;
        for(int j=0;j<klimit;j++){//组合 check， 1谁取，0谁取，注意j=0开始
            int t1=c1,t2=c2;
            for(int t=0;t<k;t++){
                if(j&(1<<t))t1-=v[t];
                else t2-=v[t];
                if(t1<0||t2<0)break;
            }
            if(t1>=0&&t2>=0){state[++tot]=i;break;}
        }
    }
}
void DP(){//0-1
    memset(dp,-1,sizeof(dp));
    dp[0]=0;
    for(int i=1;i<=tot;i++)
        for(int j=(1<<n)-1-state[i];j>=0;j--){
            if(dp[j]<0)continue;
            int k=j+state[i];
            if((j|state[i])!=k)continue;//
            if(dp[k]==-1||dp[k]>dp[j]+1)dp[k]=dp[j]+1;
        }
}
int main(){
    int T,t=1;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d%d",&n,&c1,&c2);
        for(int i=0;i<n;i++)
            scanf("%d",&w[i]);
        comb();
        DP();
        printf("Scenario #%d:\n%d\n\n",t++,dp[(1<<n)-1]);
    }
    return 0;
}

_Yuan 2010-04-12 09:45 发表评论

Poj 3214 Heap 后序遍历小于转为小于等于 LIS

_Yuan — Sun, 11 Apr 2010 14:43:00 GMT

/*
   根据题目的约束条件,可以对该树进行后序遍历
   然后对得到的序列进行调整使得其成为符合约束条件的序列。

   约束条件有:1,父亲节点的key>=子孙的key;
               2,左儿子的key<右儿子的key;

   为使<关系变为<= ，如a   依据这样子，所以每次发现<时可以-1，而这种情况是在遍历右子树时才会有<关系

若只有左孩子的时候，左孩子是可以与父亲相等的
   最后再求LIS  nlogn
*/
#include<cstdio>
#include<cstring>

const int MAXN=1024*1024+10;

int a[MAXN],x[MAXN];
int n,h;
int delta,cnt;

void dfs(int hh,int p){
    if(hh>h||p>n)return;
    if(hh<h&&p+p<=n)dfs(hh+1,p+p);
    if(hh<h&&p+p+1<=n){//every '<' +1
        delta++;
        dfs(hh+1,p+p+1);
    }
    x[++cnt]=a[p]-delta;//
}
int main(){

    n=1;
    scanf("%d",&h);
    while(~scanf("%d",&a[n]))n++;
    n--;delta=0;cnt=0;
    dfs(1,1);
    int len=0;
    for(int i=1;i<=n;i++){
        int low=1,high=len+1;
        while(high>low){
            int mid=(high+low)>>1;
            if(a[mid]>x[i])high=mid;
            else low=mid+1;
        }
        if(low==len+1)len++;
        a[low]=x[i];
    }
    printf("%d\n",n-len);
    return 0;
}

_Yuan 2010-04-11 22:43 发表评论