C++博客-糯米-随笔分类-POJ

POJ 3123 Ticket to Ride 高效解法

糯米 — Thu, 24 Feb 2011 09:16:00 GMT

低效率解法在这里。
低效率的解法是没法通过POJ的数据的。
另外一个标程中的解法十分给力，仅用时110ms（status上面还有用时16ms的）
首先来看一下这段程序：

#include <iostream>
#include <string>
#include <map>

using namespace std;

int main()
{
    int INF=99999999,N,K,d[30][30],i,j,k,x,y,z,dp[256][30],e[8],v[30],c,b;
    string s,t;
    while (cin >> N >> K && N) {
        map<string,int> cityMap;
        for(i=0;i<N;i++)
            for(j=0;j<N;j++)
                d[i][j]=i==j?0:INF;
        for(i=0;i<N;i++) {
            cin >> s;
            cityMap[s]=i;
        }
        if (K)
            while(cin >> s >> t >> z, x=cityMap[s],
                    y=cityMap[t],
                    d[x][y]=d[y][x]=min(d[y][x],z), --K);
        for(k=0;k<N;k++)
            for(i=0;i<N;i++)
                for(j=0;j<N;j++)
                    d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
        for(i=0;i<8;i++) {
            cin >> s;
            e[i]=cityMap[s];
            for(j=0;j<N;j++)
                dp[1<<i][j]=d[j][e[i]];
        }
        for(i=1;i<256;i++) {
            if (!(i&(i-1)))
                continue;
            // step1
            for(k=0;k<N;k++) {
                dp[i][k]=INF;
                v[k]=0;
                for(j=1;j<i;j++)
                    if ((i|j)==i)
                        dp[i][k]=min(dp[i][k],dp[j][k]+dp[i-j][k]);
            }
            // step2
            for(j=0;b=INF,j<N;j++) {
                for(k=0;k<N;k++)
                    if (dp[i][k]<=b && !v[k])
                        b=dp[i][c=k];
                for(k=0,v[c]=1;k<N;k++)
                    dp[i][c]=min(dp[i][c],dp[i][k]+d[k][c]);
            }
        }

        // step3
        for(i=0,b=INF;z=0,i<256;b=min(b,z),i++)
              for(j=0;y=0,j<4;z+=!!y*dp[y][x],j++)
                for(k=0;k<8;k+=2)
                      if ((i>>k&3)==j)
                        y+=3<<k,x=e[k];

        cout << b << endl;
    }
    return 0;
}

这段程序写得很让人费解。花了半天时间我才搞明白。
实际上大体的思路是跟低效率的解法一样的。
就是在求Minimal Steiner Tree这一步，它用了一种新的动态规划的方法。
动态规划的方程为：
dp[mask][i] = { 以点i为根，包含mask中的点的最小生成树的权值 }

在得知 dp[mask - 1][1...N] 的情况下，如何推出 dp[mask][1...N] 呢？
程序中分为 step1 和 step2 两个步骤。
step1 推出：
a = min{ dp[m1][i] + dp[m2][i] } 其中 m1|m2 = mask
这个很好理解。
step2 推出：
b = min{ dp[mask][j] + d[j][i] }
程序中每次都从 dp[mask][1...N] 中选出最小的一个 dp[mask][c]
按这种顺序更新就能保证结果的正确
因此 dp[mask][i] = min(a, b)

这个动态规划法的确牛逼。

step3则是枚举4条路线的各种组合情况。求出每种组合的MST权值。

代码写得很牛逼。看了半天才看懂。如果让我写，行数至少多出2，3倍来。。
老外就是牛逼，一行代码都不浪费。

糯米 2011-02-24 17:16 发表评论

POJ 3123 Ticket to Ride 动态规划+Minimal Steiner Tree

糯米 — Wed, 23 Feb 2011 16:44:00 GMT

这题绝对不是盖的。
题目大意是：
给出一个无向图，和四对数据。每对数据分别为图中的两个点。
要求添加一些边，使每对点都能连通，让总边权最小。

首先考虑一个子问题：指定一些点，添加一些边，让它们连通，并且总边权最小。
这个问题就是Minimal Steiner Tree问题，解决方法可以见这里。
这问题不是盖的，它居然是NP完全问题。。
汗。。今天终于在POJ见识到啥叫NP完全问题了。。

大的问题可以分为多个子问题。可以枚举所有pair的连接状况。
比如说 {1和2链接，3和4链接} 或者 {1独立，2独立，3和4链接} 等等
一共有15种情况。分别为
    // 1,1,1,1
   {{1},{2},{3},{4}},
   // 1,1,2
   {{1,2},{3},{4}},
   {{1,3},{2},{4}},
   {{1,4},{2},{3}},
   {{2,3},{1},{4}},
   {{2,4},{1},{3}},
   {{3,4},{1},{2}},
   // 2,2
   {{1,2},{3,4}},
   {{1,3},{2,4}},
   {{1,4},{2,3}},
   // 1,3
   {{1,2,3},{4}},
   {{1,2,4},{3}},
   {{1,3,4},{2}},
   {{2,3,4},{1}},
   // 4
   {{1,2,3,4}},

其中有一些是重复的，就可以开一个数组保存下来。
贴一个我的程序。当然，这个是TLE的。。官方的数据需要将近一分钟才能跑完。
另外一个标程运行飞快，用得是更好的方法，点这里。

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

using namespace std;

char names[32][32];
int N, M;
int W[32][32];
const int INF = 10032*32;
int pairs[4];
int dp[256][2], dn;

int getcity(char *s)
{
    int i;
    for (i = 0; i < N; i++)
        if (!strcmp(s, names[i]))
            break;
    return i;
}

int prim(int mask)
{
    int i, j, mc, mi, a, c, t;

    c = 0;
    for (i = 0; i < N; i++)
        if (mask & (1 << i)) {
            a = 1 << i;
            c++;
        }

    t = 0;
    while (--c) {
        mc = INF;
        for (i = 0; i < N; i++)
            if (a & (1 << i))
                for (j = 0; j < N; j++)
                    if (((mask ^ a) & (1 << j)) && W[i][j] < mc) {
                        mc = W[i][j];
                        mi = j;
                    }
        if (mc == INF)
            return INF;
        a |= 1 << mi;
        t += mc;
    }

    return t;
}

int K;

int dfs(int start, int mask, int n)
{
    int i, r;

    if (n >= K - 2)
        return prim(mask);

    r = prim(mask);
    for (i = start; i < N; i++)
        if ((1 << i) & ~mask)
            r = min(r, dfs(i+1, mask|(1<<i), n+1));

    return r;
}

int minicost(int mask)
{
    int i, r;

    for (i = 0; i < dn; i++)
        if (mask == dp[i][0])
            return dp[i][1];

    K = 0;
    for (i = 0; i < N; i++)
        if (mask & (1 << i))
            K++;

    r = dfs(0, mask, 0);

    dp[dn][0] = mask;
    dp[dn][1] = r;
    dn++;
    return r;
}

int stats[15][8][8] = {
    // 1,1,1,1
    {{1},{2},{3},{4}},
    // 1,1,2
    {{1,2},{3},{4}},
    {{1,3},{2},{4}},
    {{1,4},{2},{3}},
    {{2,3},{1},{4}},
    {{2,4},{1},{3}},
    {{3,4},{1},{2}},
    // 2,2
    {{1,2},{3,4}},
    {{1,3},{2,4}},
    {{1,4},{2,3}},
    // 1,3
    {{1,2,3},{4}},
    {{1,2,4},{3}},
    {{1,3,4},{2}},
    {{2,3,4},{1}},
    // 4
    {{1,2,3,4}},
};

int main()
{
    int i, j, k, a, b, c, ans;
    char sa[32], sb[32];

    while (scanf("%d%d", &N, &M), N) {
        for (i = 0; i < N; i++)
            scanf("%s", names[i]);
        for (i = 0; i < N; i++)
            for (j = 0; j < N; j++)
                W[i][j] = INF;
        for (i = 0; i < M; i++) {
            scanf("%s%s%d", sa, sb, &c);
            a = getcity(sa);
            b = getcity(sb);
            W[a][b] = W[b][a] = min(W[a][b], c);
        }
        for (i = 0; i < 4; i++) {
            scanf("%s%s", sa, sb);
            a = getcity(sa);
            b = getcity(sb);
            pairs[i] = (1 << a) | (1 << b);
        }

        // floyd
        for (k = 0; k < N; k++)
            for (i = 0; i < N; i++)
                for (j = 0; j < N; j++)
                    W[i][j] = min(W[i][k] + W[k][j], W[i][j]);

        dn = 0;
        ans = INF;
        for (i = 0; i < 15; i++) {
            c = 0;
            for (j = 0; stats[i][j][0]; j++) {
                a = 0;
                for (k = 0; stats[i][j][k]; k++)
                    a |= pairs[stats[i][j][k] - 1];
                c += minicost(a);
            }
            ans = min(ans, c);
        }

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

糯米 2011-02-24 00:44 发表评论

Minimal Steiner Tree 简介

糯米 — Wed, 23 Feb 2011 16:19:00 GMT

MinimalSteinerTree 的意思是：
在图中找出一个生成树，需要将指定的数个点连接，边权总值最小。
最小生成树是 MinimalSteinerTree 的一种特殊情况。
此问题是NP完全问题。
在POJ 3123中的标程给出了一个递归的算法来解决这个问题。

首先用floyd算法求出两两之间的最短路径。
然后把所有点都两两链接起来，权值就是它们的最短路径。
假设指定必须连接的点有N个。
那么MinimalSteinerTree 树中的内点最多有N-2个。
在纸上画一下就知道了，内点最多的情况就是树为满二叉树的情况。
而由于之前的floyd算法。把整个图给“缩”了一下。
所以树最多有N-2+N个点。
枚举所有可能的点集。对每个点集求最小生成树。取最小值即可。

另外一种方法是使用动态规划，详情请见这里。

糯米 2011-02-24 00:19 发表评论

POJ 3122 Pie 二分

糯米 — Wed, 23 Feb 2011 06:46:00 GMT

可以看出，达到最大size的时候一定是某个蛋糕刚好被分完，如果再大一点的话，肯定就不能解决了。
比这个size小，则无论如何都可以解决。

所以可以通过二分答案的方法来解决这个问题。就很简单了。
注意：这题精度要求很高，pi的值需要通过acos(-1)来求，eps要到e-5。
我用C++提交能够AC，g++一直WA。
吗的，数据能不能宽容点。

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

using namespace std;

int N, F;
double pi = acos(-1.0);
double pie[10032];
double sum, maxp;

int main()
{
    double l, r, m;
    int i, t, c;

    scanf("%d", &t);
    while (t--) {
        scanf("%d%d", &N, &F);
        F++;
        maxp = sum = 0;
        for (i = 0; i < N; i++) {
            scanf("%d", &c);
            pie[i] = c*c*pi;
            maxp = max(maxp, pie[i]);
            sum += pie[i];
        }
        l = maxp / F;
        r = sum / F;
        while (l + 0.00001 < r) {
            m = (l + r) / 2;
            c = 0;
            for (i = 0; i < N; i++)
                c += floor(pie[i] / m);
            if (c < F)
                r = m;
            else
                l = m;
        }
        printf("%.4lf\n", l);
    }

    return 0;
}

糯米 2011-02-23 14:46 发表评论

POJ 3121 The SetStack Computer 哈希

糯米 — Wed, 23 Feb 2011 06:41:00 GMT

摘要: 可以开一个闭hash表。栈里面存放的只是hash表的下标。这样比较两个set是否一样，就只需要比较他们的下标是否一样。同时对每个set，要保存它的孩子，一样存放的是hash表的下标。 union和intersect操作，如果是按序存放孩子的话，复杂度可以低至O(N)。空间复杂度为O(N^2)。 #include #include 阅读全文

糯米 2011-02-23 14:41 发表评论

POJ 3120 Sudoku 搜索

糯米 — Mon, 21 Feb 2011 12:41:00 GMT

摘要: 题目大意：给出一个已经完成的数独，和一个未完成的数独。判断前者能否经过演化后成为后者的解。演化的操作有：1）改变数字1～9的映射2）旋转数独3）交换3x9中的行或列4）交换两个3x9解法：实际上就是常规的搜索，不过代码难写点。4）中共有6*6种情况3）中共有(6*6*6)*(6*6*6)种情况在搜索3）的时候，首先固定列，然后枚举行，这样就可以节省一些时间。我的代码 250ms Code hig... 阅读全文

糯米 2011-02-21 20:41 发表评论

POJ 3156 Interconnect 图论+数论

糯米 — Sat, 19 Feb 2011 03:01:00 GMT

题目的意思是：
给一个有n个点，m条边的无向图
两点之间可以存在多条边
现在每次随机增加一条边
问使得全部点都连通需要增加多少次（期望值）

首先，求出所有连通分量。用并查集。
每次随机增加一条边的时候一共有两种情况：
1）这条边连接了两个不同的连通分量，它的概率是p
2）这条边在一个连通分量里，它的概率是q = 1 - p
前者可以改变连通分量的数量，后者不能

如果把当前图的状态视为一个子问题
那么就可以用动态规划解决问题了
图的状态可以表示为：有多少个连通分量，每个连通分量包含多少个点
比如说图的状态 (2, 3, 3) 表示有三个连通分量，每个连通分量包含的点的个数分别为 2, 3, 3

动态规划的转移方程为：
f = p*(1+r) + p*q*(2+r) + p*q^2*(3+r) ....
其中r为p发生后，新状态的期望值
这个东西高中的时候学过，呵呵。

而1）中也包含多种情况，需要两两枚举
最大的问题是，f的值是一个无限数列，它的极值很难求。但无论如何，有高手求出来了。。在这里：http://archive.cnblogs.com/a/1325929/
它的极值是 f = p * (1 / (1 - q) + r) / (1 - q)
我对照了一下标程，确实是这个。
后来我自己推导了一下，发现它可以化成多个等比数列相加的形式，求和后，发现当n趋向于无穷大的时候，它的极限就是上面这个公式。
（注意：i*q^i, 当0
这样程序就可以写了。动态规划保存每个图的状态。
如果用python写，只要建立一个tuple到float的映射就可以了。非常方便。
java中也有List到Double的映射。
c里面估计就得用hash了。

py代码，参照标程写的。

fi = open('in')
fo = open('out')
dp = {():0}
ti = 0

def get(s):
    if s in dp:
        return dp[s]
    q = sum([i*(i-1) for i in s])*1.0/2/nn
    res = 0
    for i in range(len(s)):
        for j in range(len(s)):
            if i < j:
                l = list(s)
                del l[max(i,j)]
                del l[min(i,j)]
                l.append(s[i]+s[j])
                l.sort()
                r = get(tuple(l))
                p = s[i]*s[j]*1.0/nn
                res += p*(1+r-r*q)/pow(1-q,2)
    dp[s] = res
    return res

while 1:
    a = fi.readline().split()
    if a == None or len(a) != 2:
        break
    N, M = int(a[0]), int(a[1])
    nn = N*(N-1)/2
    s = [ i for i in range(N) ]
    for i in range(M):
        u, v = [ int(i) for i in fi.readline().split() ]
        u -= 1
        v -= 1
        k = s[u]
        for j in range(N):
            if s[j] == k:
                s[j] = s[v]
    ss = [ s.count(i) for i in set(s) ]
    ss.sort()
    print '----', ti
    mine = get(tuple(ss))
    ans = float(fo.readline().strip())
    print 'mine', mine, 'ans', ans
    print len(dp)
    ti += 1

标程
用很简洁的代码写了并查集，值得借鉴！

import java.util.*;
import java.io.File;
import java.io.PrintWriter;
import java.io.FileNotFoundException;

public class interconnect_pm {

    private static int nn;

    public static void main(String[] args) throws FileNotFoundException {
        Scanner in = new Scanner(new File("in"));
        PrintWriter out = new PrintWriter("ans.out");
        int n = in.nextInt();
        nn = (n * (n - 1)) / 2;
        int m = in.nextInt();
        int[] p = new int[n];
        for (int i = 0; i < n; i++) p[i] = i;
        for (int i = 0; i < m; i++) {
            int u = in.nextInt();
            int v = in.nextInt();
            u--;
            v--;
            int k = p[u];
            for (int j = 0; j < n; j++) {
                if (p[j] == k) {
                    p[j] = p[v];
                }
            }
        }
        List<Integer> st = new ArrayList<Integer>();
        for (int i = 0; i < n; i++) {
            int s = 0;
            for (int j = 0; j < n; j++) {
                if (p[j] == i) s++;
            }
            if (s > 0) {
                st.add(s);
            }
        }
        Collections.sort(st);
        List<Integer> fn = new ArrayList<Integer>();
        fn.add(n);
        mem.put(fn, 0.0);
        out.println(get(st));
        System.out.println(mem.size());
        out.close();
    }

    static Map<List<Integer>, Double> mem = new HashMap<List<Integer>, Double>();

    private static double get(List<Integer> st) {
        Double ret = mem.get(st);
        if (ret != null) return ret;
        int m = st.size();
        int[][] a = new int[m][m];
        for (int i = 0; i < m; i++) {
            for (int j = i + 1; j < m; j++) {
                a[i][j] = st.get(i) * st.get(j);
            }
        }
        int s = 0;
        for (int i = 0; i < m; i++) {
            s += st.get(i) * (st.get(i) - 1) / 2;
        }
        double res = 0;
        for (int i = 0; i < m; i++) {
            for (int j = i + 1; j < m; j++) {
                List<Integer> ss = new ArrayList<Integer>(st.size() - 1);
                boolean q = true;
                int z = st.get(i) + st.get(j);
                for (int k = 0; k < m; k++) {
                    if (k != i && k != j) {
                        int zz = st.get(k);
                        if (q && zz >= z) {
                            q = false;
                            ss.add(z);
                        }
                        ss.add(zz);
                    }
                }
                if (q)
                    ss.add(z);
                double p = a[i][j] * 1.0 / (nn - s);
                double e = a[i][j] * 1.0 / ((1 - s * 1.0 / nn) * (1 - s * 1.0 / nn) * nn);
                e = e + get(ss) * p;
                res += e;
            }
        }
        System.out.println(st);
        mem.put(st, res);
        return res;
    }

}

糯米 2011-02-19 11:01 发表评论

POJ 3155 Hard Life 最大密度子图

糯米 — Tue, 15 Feb 2011 07:40:00 GMT

这题真不是盖的，要是不看解题报告，恐怕一辈子都做不出来啦。。
题目直接就是要解决一个叫做“最大密度子图的问题”。
就是在一简单图里面找出n个点，这n个点之间有m条边，让m/n最大。
这种问题还是有点实际意义的。

算法很复杂，找了一份高中生巨牛写的文档（90后真不是盖的）。http://wenku.baidu.com/view/986baf00b52acfc789ebc9a9.html 。
该文档描述了一系列的最小割算法，其中包括这个“最大密度子图问题”。
我编码能力差，不想写c代码，写了一个py的脚本，能过官方数据，就是速度巨慢，开了一分钟也没跑完。。

import sys

def dinic(N, S, T, caps):
    to = []
    cap = []
    head = [[] for i in range(N)]
    d = [-1]*N
    ans = 0
    cut = set()

    for a, b, c in caps:
        head[a].append(len(cap))
        cap.append(c)
        to.append(b)
        head[b].append(len(cap))
        cap.append(0)
        to.append(a)

    def build():
        for i in range(N):
            d[i] = -1
        q = [S]
        d[S] = 0
        cut.clear()
        while len(q):
            x = q[0]
            del q[0]
            for i in head[x]:
                y = to[i]
                if cap[i] and d[y] == -1:
                    d[y] = d[x] + 1
                    if y == T:
                        return 1
                    q.append(y)
                    cut.add(y)
        return 0

    def find(x, low):
        if x == T:
            return low
        for i in head[x]:
            y = to[i]
            if cap[i] and d[y] == d[x] + 1:
                f = find(y, min(low, cap[i]))
                if f:
                    cap[i] -= f
                    cap[i^1] += f
                    return f
        return 0

    while build():
        while 1:
            f = find(S, sum(cap))
            if f == 0:
                break
            ans += f

    return ans, cut

def max_weight_closure(V, edges):
    inf = sum([abs(i) for i in V])
    caps = [(a,b,inf) for a,b in edges]
    S = len(V)
    T = S + 1
    for i in range(len(V)):
        if V[i] > 0:
            caps.append((S,i,V[i]))
        elif V[i] < 0:
            caps.append((i,T,-V[i]))
    flow, cut = dinic(len(V)+2, S, T, caps)
    return sum([V[i] for i in cut]), cut

def max_density_subgraph(N, edges):

    def solve(g):
        V = [-g]*N
        E = []
        for u,v in edges:
            ve = len(V)
            E += [(ve,u), (ve,v)]
            V.append(1)
        w, cut = max_weight_closure(V, E)
        if len(cut) == 0:
            w = -1
        return w, cut

    l = 1.0/N
    r = len(edges)
    while l < r - 0.01:
        m = (l + r) / 2
        if solve(m)[0] < 0:
            r = m
        else:
            l = m
    w, cut = solve(l)
    l = [ i for i in cut if i < N]
    if len(l) == 0:
        l = [0]
    return l

def get_density(N, edges, sel):
    e = float(len([1 for a,b in edges if a in sel and b in sel]))
    return e/float(len(sel))

fi = open('3155.in')
fo = open('3155.out')
g = lambda x : [ int(i) for i in x.readline().split(' ') ]

ti = 0
while 1:
    l = g(fi)
    if len(l) == 0:
        break
    N, M = l
    print '----', ti
    print 'N M', N, M
    E = [ [j-1 for j in g(fi)] for i in range(M)]
    cut = max_density_subgraph(N, E)
    k = g(fo)[0]
    ans = [g(fo)[0]-1 for i in range(k)]
    d_ans = get_density(N, E, ans)
    d_mine = get_density(N, E, cut)
    print 'mine', d_mine
    print 'ans', d_ans
    if abs(d_ans - d_mine) > 0.001:
        print 'error'
        break
    ti += 1

糯米 2011-02-15 15:40 发表评论

POJ 3154 Graveyard 模拟

糯米 — Tue, 08 Feb 2011 09:23:00 GMT

可以认为，新的平分点和旧的平分点中一定有一个点是重合的。
这样此题就变成了一个纯模拟的问题了。
写了个脚本，可以过官方的数据。

import sys

f = sys.stdin
D = 10000.0
for s in f.readlines():
    n, m = [ int(i) for i in s.split(' ') ]
    m += n
    b = 0
    ans = 0
    g = lambda x,y: D*x/y
    for a in range(n):
        while g(b, m) <= g(a, n):
            b += 1
        d = min(abs(g(b, m) - g(a, n)), abs(g(b - 1, m) - g(a, n)))
        ans += d
    print ans

糯米 2011-02-08 17:23 发表评论

POJ 3150 Cellular Automaton 矩阵乘法+二分

糯米 — Tue, 08 Feb 2011 08:07:00 GMT

这题对我来说太难啦，看了报告半天才弄明白是咋回事。
高手们的解题报告相当飘逸。我来写一个造福菜鸟的。

首先来看一下Sample里的第一组数据。
1 2 2 1 2
经过一次变换之后就成了
5 5 5 5 4
它的原理就是
a0 a1 a2 a3 a4
->
(a4+a0+a1) (a0+a1+a2) (a1+a2+a3) (a2+a3+a4) (a3+a4+a0)

如果用矩阵相乘来描述，那就可以表述为1xN和NxN的矩阵相乘，结果仍为1xN矩阵
a = 1 2 2 1 2
b =
1 1 0 0 1
1 1 1 0 0
0 1 1 1 0
0 0 1 1 1
1 0 0 1 1
a * b = 5 5 5 5 4
所以最终结果就是：a * (b^k)

线性代数不合格的同鞋表示压力很大。。

对一个NxN矩阵求k次方，而且这个k很大，N也不小，怎么办？
所以有高手观察到了，这个矩阵长得有点特殊，可以找到一些规律：
b^1 =
[1, 1, 0, 0, 1]
[1, 1, 1, 0, 0]
[0, 1, 1, 1, 0]
[0, 0, 1, 1, 1]
[1, 0, 0, 1, 1]
b^2 =
[3, 2, 1, 1, 2]
[2, 3, 2, 1, 1]
[1, 2, 3, 2, 1]
[1, 1, 2, 3, 2]
[2, 1, 1, 2, 3]
b^3 =
[7, 6, 4, 4, 6]
[6, 7, 6, 4, 4]
[4, 6, 7, 6, 4]
[4, 4, 6, 7, 6]
[6, 4, 4, 6, 7]
b^4 =
[19, 17, 14, 14, 17]
[17, 19, 17, 14, 14]
[14, 17, 19, 17, 14]
[14, 14, 17, 19, 17]
[17, 14, 14, 17, 19]

发现神马没有。就是无论是b的几次幂，都符合A[i][j] = A[i-1][j-1]
高手说是这样推倒出来地：
““”
利用矩阵A，B具有a[i][j]=A[i-1][j-1],B[i][j]=B[i-1][j-1]（i-1<0则表示i-1+n,j-1<0则表示j-1+n）
我们可以得出矩阵C=a*b也具有这个性质
C[i][j]=sum(A[i][t]*B[t][j])=sum(A[i-1][t-1],B[t-1][j-1])=sum(A[i-1][t],B[t][j-1])=C[i-1][j-1]
“”“

这样就可以开一个N大小的数组来存放每次计算的结果了。而没必要用NxN。
N的问题解决了，但是k还是很大，怎么办？

这时候可以用二分法来求b^k
b^k = b^1 * b^4 * b^16 。。。

计算过程中，必定会出现数字大于M的情况。
切记 x*y = (x%M)*(y%M)

最后，经过多次优化，这题的代码居然被高手写成了如下的一小坨，实在是。。给力哇

#include<iostream>
using namespace std;
int n,m,d,k;
void mul(long long a[],long long b[])
{
      int i,j;
      long long c[501];
      for(i=0;i<n;++i)for(c[i]=j=0;j<n;++j)c[i]+=a[j]*b[i>=j?(i-j):(n+i-j)];
      for(i=0;i<n;b[i]=c[i++]%m);
}
long long init[501],tmp[501];
int main()
{
    int i,j;
    scanf("%d%d%d%d",&n,&m,&d,&k);
    for(i=0;i<n;++i)scanf("%I64d",&init[i]);
    for(tmp[0]=i=1;i<=d;++i)tmp[i]=tmp[n-i]=1;
    while(k)
    {
            if(k&1)mul(tmp,init);
            mul(tmp,tmp);
            k>>=1;
    }
    for(i=0;i<n;++i)if(i)printf(" %I64d",init[i]);else printf("%I64d",init[i]);
    printf("\n");
    return 0;
}

糯米 2011-02-08 16:07 发表评论

POJ 3148 ASCII Art

糯米 — Sat, 29 Jan 2011 03:51:00 GMT

此题看了官方标程，才知道怎么做，其解法实在是相当巧妙！

数据给出的点是顺时针顺序的，这点非常重要，我们可以根据这个整理出每条线段的方向。

我们可以发现这个规律：
对于某一列格子，在遇到第一条线段之前，一定是空白的，在第一条线段与第二条线段之间，一定是填充的。。以此类推。
而且经过这一列格子的线段数一定是偶数。

标程给出的算法是：
开一个二维数组保存每个格子黑色部分的面积。
如果这个线段是从左到右的，那么就给这条线段以上的格子加上一个负的面积。
如果是从右到左的，则加上一个正的面积。
如果是垂直的，则忽略这条线段。

比如说第一条线段是从左到右的，在它以上一共有5个格子，面积依次为：-0.3 -0.6 -1.0 -1.0 -0.6 （大概的数字）
第二条线段是从右到左的，在它以上一共有9个格子，面积依次为：1.0 1.0 1.0 1.0 1.0 1.0 0.6 0.5 0.3
第三条线段是垂直的，忽略它。
第四条线段是从左到右的，在它以上一共有16个格子。。（其中有一个很小很小的）
等等。

给这些格子加上或正或负的增量之后，会发现，恰好完全空白的地方的面积都是0，都被抵消了。
而部分黑色的格子，它的值也是正确的。这就是这个算法的神奇之处～

标程在这里

{$APPTYPE CONSOLE}
{$R+,Q+,S+,H+,O-}

uses
  Math, SysUtils;

Type
  Integer=LongInt;
  Real=Extended;

Const
  TaskID='ascii';
  InFile=TaskID+'.in';
  OutFile=TaskID+'.out';
  MaxN=100;
  MaxSize=100;
  Eps=1e-12;

Var
  N,W,H:Integer;
  X,Y:Array[1..MaxN]Of Integer;
  Res:Array[-1..MaxSize,-1..MaxSize]Of Real;

Procedure Load;
Var
  I:Integer;
Begin
  ReSet(Input,InFile);
  Read(N,W,H);
  For I:=1 To N Do Read(X[I],Y[I]);
  Close(Input);
End;

Function Floor(A:Real):Integer;
Begin
  Result:=Trunc(A+1000)-1000;
End;

Function Ceil(A:Real):Integer;
Begin
  Result:=-Floor(-A);
End;

Procedure Process(X1,Y1,X2,Y2,By:Integer);
Var
  I,X,Y,U,D:Integer;
  XU,XD,YL,YR,Tmp:Real;
Begin
  For X:=X1 To X2-1 Do Begin
    YL:=(X-X1)/(X2-X1)*(Y2-Y1)+Y1;
    YR:=((X+1)-X1)/(X2-X1)*(Y2-Y1)+Y1;
    If YL<YR Then Begin
      For I:=0 To Floor(YL)-1 Do Res[X,I]:=Res[X,I]+By;
      D:=Floor(YL);
      U:=Ceil(YR)-1;
      If D=U Then Begin
        Res[X,D]:=Res[X,D]+By*(YL-D+YR-D)/2;
      End Else If D<U Then Begin
        XU:=(D+1-Y1)/(Y2-Y1)*(X2-X1)+X1;
        Res[X,D]:=Res[X,D]+By*(1-(XU-X)*(D+1-YL)/2);
        XD:=(U-Y1)/(Y2-Y1)*(X2-X1)+X1;
        Res[X,U]:=Res[X,U]+By*((YR-U)*(X+1-XD)/2);
        For I:=D+1 To U-1 Do Begin
          XU:=(I+1-Y1)/(Y2-Y1)*(X2-X1)+X1;
          XD:=(I-Y1)/(Y2-Y1)*(X2-X1)+X1;
          Res[X,I]:=Res[X,I]+By*(X+1-XD+X+1-XU)/2;
        End;
      End;
    End Else Begin
      For I:=0 To Floor(YR)-1 Do Res[X,I]:=Res[X,I]+By;
      D:=Floor(YR);
      U:=Ceil(YL)-1;
      If D=U Then Begin
        Res[X,D]:=Res[X,D]+By*(YL-D+YR-D)/2;
      End Else If D<U Then Begin
        XU:=(D+1-Y1)/(Y2-Y1)*(X2-X1)+X1;
        Res[X,D]:=Res[X,D]+By*(1-(X+1-XU)*(D+1-YR)/2);
        XD:=(U-Y1)/(Y2-Y1)*(X2-X1)+X1;
        Res[X,U]:=Res[X,U]+By*((YL-U)*(XD-X)/2);
        For I:=D+1 To U-1 Do Begin
          XU:=(I+1-Y1)/(Y2-Y1)*(X2-X1)+X1;
          XD:=(I-Y1)/(Y2-Y1)*(X2-X1)+X1;
          Res[X,I]:=Res[X,I]+By*(XD-X+XU-X)/2;
        End;
      End;
    End;
  End;
End;

Procedure Solve;
Var
  I,X1,Y1,X2,Y2:Integer;
Begin
  FillChar(Res,SizeOf(Res),0);
  For I:=1 To N Do Begin
    X1:=X[I];
    Y1:=Y[I];
    X2:=X[I Mod N+1];
    Y2:=Y[I Mod N+1];
    If X1=X2 Then Continue;
    If X1<X2 Then
      Process(X1,Y1,X2,Y2,1)
    Else
      Process(X2,Y2,X1,Y1,-1);
  End;
End;

Procedure Save;
Var
  X,Y:Integer;
  R:Real;
Begin
  ReWrite(Output,OutFile);
  For Y:=H-1 DownTo 0 Do Begin
    For X:=0 To W-1 Do Begin
      R:=Res[X,Y];
      If R<1/4-Eps Then Write('.') Else If R<1/2-Eps Then Write('+') Else If R<3/4-Eps Then Write('o') Else If R<1-Eps Then Write('$') Else Write('#');
    End;
    WriteLn;
  End;
  Close(Output);
End;

begin
  Load;
  Solve;
  Save;
end.

糯米 2011-01-29 11:51 发表评论

[转] Floyd 算法原理

糯米 — Sat, 15 Jan 2011 02:56:00 GMT

floyd算法是一个经典的动态规划算法。用通俗的语言来描述的话，首先我们的目标是寻找从点i到点j的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力的精华所在），floyd算法加入了这个概念

A^k(i,j)：表示从i到j中途不经过索引比k大的点的最短路径。

这个限制的重要之处在于，它将最短路径的概念做了限制，使得该限制有机会满足迭代关系，这个迭代关系就在于研究：假设A^k(i,j)已知，是否可以借此推导出A^k-1(i,j)。

假设我现在要得到A^k(i,j)，而此时A^k(i,j)已知，那么我可以分两种情况来看待问题：1. A^k(i,j)沿途经过点k；2. A^k(i,j)不经过点k。如果经过点k，那么很显然，A^k(i,j) = A^k-1(i,k) + A^k-1(k,j)，为什么是A^k-1呢？因为对(i,k)和(k,j)，由于k本身就是源点（或者说终点），加上我们求的是A^k(i,j)，所以满足不经过比k大的点的条件限制，且已经不会经过点k，故得出了A^k-1这个值。那么遇到第二种情况，A^k(i,j)不经过点k时，由于没有经过点k，所以根据概念，可以得出A^k(i,j)=A^k-1(i,j)。现在，我们确信有且只有这两种情况---不是经过点k，就是不经过点k，没有第三种情况了，条件很完整，那么是选择哪一个呢？很简单，求的是最短路径，当然是哪个最短，求取哪个，故得出式子：

A^k(i,j) = min( A^k-1(i,j), A^k-1(i,k) + A^k-1(k,j) )

因此floyd的最外层循环：
for (k = 0; k < n; k++) ...
就是分别求出 A0(i,j), A1(i,j), ..., An(i,j)
我屡次写错floyd的程序，今天又写错一次。。尽管它很短，但原理真的很牛比。
只要知道了原理，就不会再写错了！

糯米 2011-01-15 10:56 发表评论

HDU 2830 Matrix Swapping II 动态规划

糯米 — Mon, 25 Oct 2010 14:19:00 GMT

这题需要动动脑子，可以找到O(NM)的算法。
但是表述很麻烦，还是看代码吧。。

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

int N, M;
int end[1024], sum[1024];
char mat[1024][1024];

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

    while (scanf("%d%d", &N, &M) != EOF) {
        memset(end, 0, sizeof(end));
        memset(sum, 0, sizeof(sum));
        for (i = 0; i < N; i++)
            scanf("%s", mat[i]);
        ans = 0;
        for (i = 0; i < N; i++) {
            for (j = 0; j < M; j++) {
                if (mat[i][j] == '1' && end[j] <= i) {
                    for (k = i; k < N && mat[k][j] == '1'; k++)
                        sum[k]++;
                    end[j] = k;
                }
            }
            for (j = i; j < N && sum[j]; j++) {
                v = (j - i + 1) * sum[j];
                if (v > ans)
                    ans = v;
            }
        }
        printf("%d\n", ans);
    }

    return 0;
}

糯米 2010-10-25 22:19 发表评论

HDU 2819 Swap 二分图的最大匹配

糯米 — Mon, 25 Oct 2010 14:01:00 GMT

这题的目的是，通过一系列交换，让矩阵中A[i, i] (1 <= i <= N)的值全为1。
首先要明确：
如果某行或者某列全是0。那怎么换都没办法的。
否则，一定能换出来。
这个动动脑子想一下可以明白的。

其次要明确：只交换行或者只交换列都是可以换出来的。
这个动动脑子想一下也可以明白的。

明确了这两点，这问题就变成了二分图的匹配问题。
二分图左边的节点为每一行的行号
二分图右边的节点为每一行中出现的“1”对应的列号
这样用匈牙利算法就可以匹配了。

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

#define NR 128

int N;
int mat[NR][NR];
int res[NR];
char vis[NR];

int dfs(int i)
{
    int j;

    for (j = 1; j <= N; j++) {
        if (mat[i][j] && !vis[j]) {
            vis[j] = 1;
            if (!res[j] || dfs(res[j])) {
                res[j] = i;
                return 1;
            }
        }
    }

    return 0;
}

int solve()
{
    int i, j, k, c, t, m;
    static int a[NR], b[NR];

    for (i = 1; i <= N; i++)
        for (j = 1; j <= N; j++)
            scanf("%d", &mat[i][j]);

    memset(res, 0, sizeof(res));
    for (i = 1; i <= N; i++) {
        memset(vis, 0, sizeof(vis));
        if (!dfs(i))
            return 0;
    }

    c = 0;
    for (j = 1; j <= N; j++) {
        m = j;
        for (k = j; k <= N; k++)
            if (res[k] <= res[m])
                m = k;
        if (m != j) {
            a[c] = m;
            b[c] = j;
            c++;
            t = res[m];
            res[m] = res[j];
            res[j] = t;
        }
    }

    printf("%d\n", c);
    for (i = 0; i < c; i++)
        printf("C %d %d\n", a[i], b[i]);

    return 1;
}

int main()
{
    while (scanf("%d", &N) != EOF)
        if (!solve())
            printf("-1\n");

    return 0;
}

糯米 2010-10-25 22:01 发表评论

POJ 2362 Square 搜索

糯米 — Mon, 04 Oct 2010 05:08:00 GMT

题意：
给出N条木棍的长度，问能不能用这些木棍拼成一个正方形。

思路：
这题一开始想复杂了，后来发现只要2个最简单的剪枝题目就能79ms通过了。
再加上一个比较屌的剪枝就可以到16ms。
参考了网上的代码，很多份代码如出一辙。思想十分牛逼。

剪枝1：
所有木棍的长度必须能被4整除

剪枝2：
最长的木棍不能长于正方形的边长

这两个是最容易想到的，用上这两个可以79ms通过

剪枝3：
同样长度的木棍的同样数量的组合只搜索一次。
这个剪枝需要将木棍从大到小排列，在搜索的时候加一句代码就行了，代码很巧妙。
由于数据问题，这个剪枝貌似不管用。

剪枝4：
每条边的木棍按照从大到小的顺序拼接
如果某条木棍不能够作为某边的第一条木棍，那比它短的也不行
想一想还是可以理解，后面的边始终会用到这条长的棍子，那时候可供选择的木棍更少
所以在前面的边拼不成，在后面的边更加拼不成
这个剪枝非常牛逼，不知道谁想出来的，代码只需要一句。太牛逼了。
由于数据的N比较小，这个剪枝相当管用。

无法实现的理想化剪枝：
如果在枚举中，发现用一条长的棍子枚举失败，那么几条短的棍子组成同样长度的棍子也必然不用试验。
这个很理想，但是实现的代价很大。

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

// 1+2 : 79ms
// 1+2+3 : 79ms
// 1+2+4 : 16ms
// 1+2+3+4: 16ms

int part, N;
int len[128];
char used[128];

int cmp(const void *a, const void *b)
{
    return *(int *)b - *(int *)a;
}

int dfs(int side, int start, int left)
{
    int i;

    if (!left) {
        left = part;
        side++;
        start = 0;
    }

    if (side == 4)
        return 1;

    for (i = start; i < N; i++) {
        if (len[i] > left)
            continue;
        if (used[i])
            continue;

        // 3
        if (i && !used[i - 1] && len[i] == len[i - 1])
            continue;

        used[i] = 1;
        if (dfs(side, i + 1, left - len[i]))
            return 1;
        used[i] = 0;

        // 4
        if (left == part)
            return 0;
    }

    return 0;
}

int solve()
{
    int i, sum;

    scanf("%d", &N);
    sum = 0;
    for (i = 0; i < N; i++) {
        scanf("%d", &len[i]);
        sum += len[i];
    }

    // 1
    if (sum % 4)
        return 0;

    part = sum / 4;
    qsort(len, N, sizeof(len[0]), cmp);
    // 2
    if (len[0] > part)
        return 0;

    memset(used, 0, N);
    return dfs(0, 0, part);
}

int main()
{
    int t;

    scanf("%d", &t);
    while (t--)
        printf("%s\n", solve() ? "yes" : "no");

    return 0;
}

糯米 2010-10-04 13:08 发表评论

POJ 1920 Towers of Hanoi 汉诺塔问题

糯米 — Mon, 27 Sep 2010 06:58:00 GMT

题目大意：
给出一个玩到一半的汉诺塔。叫你把所有的盘子归到任意一根针上，求最少步数。

由于结果很大，输出它和100000的模。

最基本的思路是动态规划，跟一般的汉诺塔问题类似
位于任意一个状态的汉诺塔。必然有位于最底层的最大的盘子。
最终的目的是把这个盘子移动到某根针上。
所以必然会出现的一个场景就是：
最大的盘子单独在一根针上，其他的盘子在另外一根针上

假设：
f(n, idx) = { 将初始状态下盘子 1~n 集中到第idx根针上所需要的最小步数 }
g(n) = { 将位于一根针上的盘子 1~n 移动到另外一根针所需要的最小步数 }

那么转移方程就是：
f(n, idx) = {
如果盘子n位于idx：f(n - 1, idx)
否则：f(n - 1, idx)
}

从普通的汉诺塔问题上可以得出：
g(n) = 2^n - 1

糯米 2010-09-27 14:58 发表评论

POJ 1934 Trip 打印出所有的最长公共子序列

糯米 — Mon, 27 Sep 2010 06:30:00 GMT

这题很难，我只写出了一个TLE的版本。
后来找了解题报告，只找到了一个，就是这位alpc43大牛的版本：
http://hi.baidu.com/alpc43/blog/item/95184e03a5fef4e209fa932d.html

这个代码很牛逼！
它的思路是：

1）首先按照常规的方法求出最长公共子序列的长度
也就是用O(MN)的那个动态规划，结果放在二维数组dp里
dp[i][j] = { 字串a的1~i部分与字串b的1~j部分的最长公共子序列的长度 }
2）求辅助数组
last1[i][j] = { 到下标i为止，字符j在字串a中最后一次出现的下标 }
last2[i][j] = { 到下标i为止，字符j在字串b中最后一次出现的下标 }
3）枚举最长公共字串的每一个字符
从最后一个字符开始枚举
比如说现在枚举最后一个字符是'C'的情况。
那么 'CDCD' 与 'FUCKC' 这两个字串。
一共有 (0, 2) (0, 4) (2, 2) (2. 4) 这四种可能。
很明显前三个是可以舍弃的，因为第四个优于前三个，为后续的枚举提供了更大的空间。
last数组正好是用来做这个的。
4）排序输出
代码里用了stl的set。
注意，由于刚刚的枚举过程是针对每个字符，所以是不用判重的。

这个思路非常之牛逼！

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <string>
#include <set>;

using namespace std;

const int MAXLEN=100;
char s1[MAXLEN];
char s2[MAXLEN];
int len1,len2;
int dp[MAXLEN][MAXLEN];
int last1[MAXLEN][27];
int last2[MAXLEN][27];
int longest;
char temp[MAXLEN];
set<string> SET;
void input()
{
    scanf("%s %s",&s1[1],&s2[1]);

}
inline int maxab(int a,int b)
{
    if(a>b) return a;
    return b;
}

inline void find(int x,int y,int len)
{
    if(len<=0)
    {
        //printf("%s\n",&temp[1]);
        SET.insert(&temp[1]);
        return ;
    }
    int i,j;
    if(x>0 && y>0)
    {
        for(i=0;i<26;i++)
        {
            int t1=last1[x][i];
            int t2=last2[y][i];
            if(dp[t1][t2]==len)
            {
                temp[len]='a'+i;
                find(t1-1,t2-1,len-1);
            }
        }
    }
}
void solve()
{
    int i,j,k;
    len1=strlen(&s1[1]);
    len2=strlen(&s2[1]);
    for(i=0;i<=len1;i++)
        dp[i][0]=0;
    for(i=0;i<=len2;i++)
        dp[0][i]=0;
    for(i=1;i<=len1;i++)
        for(j=1;j<=len2;j++)
        {
            if(s1[i]==s2[j])
                dp[i][j]=dp[i-1][j-1]+1;
            else dp[i][j]=maxab(dp[i-1][j],dp[i][j-1]);
        }
        longest=dp[len1][len2];

        for(j=0;j<26;j++)
            for(i=0;i<=len1;i++)
                last1[i][j]=0;
        for(j=0;j<26;j++)
            for(i=0;i<=len2;i++)
                last2[i][j]=0;
        for(i=1;i<=len1;i++)
        {
            for(j=0;j<26;j++)
            {
                if(s1[i]=='a'+j)
                    last1[i][j]=i;
                else last1[i][j]=last1[i-1][j];
            }
        }
        for(i=1;i<=len2;i++)
        {
            for(j=0;j<26;j++)
            {
                if(s2[i]=='a'+j)
                    last2[i][j]=i;
                else last2[i][j]=last2[i-1][j];
            }
        }
        temp[longest+1]='\0';
        find(len1,len2,longest);
        set<string>::iterator it;
        for(it=SET.begin();it!=SET.end();it++)
        {
            printf("%s\n",(*it).c_str());
        }
}
int main()
{
    freopen("e:\\in.txt", "r", stdin);

    input();
    solve();
    return 0;
}

糯米 2010-09-27 14:30 发表评论

Dinic 算法模板

糯米 — Thu, 12 Aug 2010 06:33:00 GMT

Dinic算法是一种比较容易实现的，相对比较快的最大流算法。
今天看了一下它的原理，发现的确很牛逼。

求最大流的本质，就是不停的寻找增广路径。直到找不到增广路径为止。
对于这个一般性的过程，Dinic算法的优化如下：

（1）
Dinic算法首先对图进行一次BFS，然后在BFS生成的层次图中进行多次DFS。
层次图的意思就是，只有在BFS树中深度相差1的节点才是连接的。
这就切断了原有的图中的许多不必要的连接。很牛逼！
这是需要证明的，估计证明也很复杂。

（2）
除此之外，每次DFS完后，会找到路径中容量最小的一条边。
在这条边之前的路径的容量是大于等于这条边的容量的。
那么从这条边之前的点，可能引发出别的增广路径。
比如说 S -> b -> c -> d -> T 是一条增广路径，容量最小的边是 b -> c。
可能存在一条 S -> b -> e -> f -> g -> T 这样的增广路径。
这样的话，在找到第一条增广路径后，只需要回溯到 b 点，就可以继续找下去了。
这样做的好处是，避免了找到一条路径就从头开始寻找另外一条的开销。
也就是再次从 S 寻找到 b 的开销。
这个过程看似复杂，但是代码实现起来很优雅，因为它的本质就是回溯！

（3）
在同一次 DFS 中。如果从一个点引发不出任何的增广路径，就将这个点在层次图中抹去。

而这样一个算法，实现起来居然只需要100行。太吊了。
我的代码是参考别人的代码写的。可以用 POJ 1273 测试。

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

#define MAX_VETXS 1024
#define MAX_EDGES 1024

int E[MAX_EDGES], next[MAX_EDGES], C[MAX_EDGES], M;
int V[MAX_VETXS], L[MAX_VETXS], Q[MAX_VETXS], N;
int S, T;

void __insert(int from, int to, int cap)
{
    M++;
    C[M] = cap;
    E[M] = to;
    next[M] = V[from];
    V[from] = M;
}

void insert(int from, int to, int cap)
{
    __insert(from, to, cap);
    __insert(to, from, 0);
}

int bfs()
{
    int h, t, e, u, v;

    h = t = 0;
    Q[t++] = S;
    memset(L, 0, N*sizeof(L[0]));
    L[S] = 1;
    while (h != t) {
        u = Q[h++];
        for (e = V[u]; e; e = next[e]) {
            v = E[e];
            if (!L[v] && C[e] > 0) {
                L[v] = L[u] + 1;
                Q[t++] = v;
            }
        }
    }

    return L[T];
}

int dfs()
{
    int t, u, v, e, i, f, r, back;

    t = 1;
    r = 0;

    while (t) {
        u = (t == 1) ? S : E[Q[t - 1]];
        if (u == T) {
            f = INT_MAX;
            for (i = 1; i < t; i++) {
                e = Q[i];
                if (C[e] < f) {
                    f = C[e];
                    back = i;
                }
            }
            for (i = 1; i < t; i++) {
                e = Q[i];
                C[e] -= f;
                C[e^1] += f;
            }
            r += f;
            t = back;
        } else {
            for (e = V[u]; e; e = next[e]) {
                v = E[e];
                if (L[v] == L[u] + 1 && C[e] > 0)
                    break;
            }
            if (e)
                Q[t++] = e;
            else {
                t--;
                L[u] = 0;
            }
        }
    }

    return r;
}

int dinic()
{
    int f = 0;

    while (bfs())
        f += dfs();

    return f;
}

int main()
{
    int n, m, a, b, c, i;

    freopen("d:\\in.txt", "r", stdin);

    while (scanf("%d%d", &n, &m) != EOF) {
        S = 0;
        T = m - 1;
        N = m;
        memset(V, 0, N*sizeof(V[0]));
        M = 2;
        for (i = 0; i < n; i++) {
            scanf("%d%d%d", &a, &b, &c);
            insert(a - 1, b - 1, c);
        }
        printf("%d\n", dinic());
    }

    return 0;
}

糯米 2010-08-12 14:33 发表评论

POJ 2050 Searching the Web 数据结构

糯米 — Fri, 23 Jul 2010 05:24:00 GMT

摘要: 这题基本上没有算法，只用了一个字符串的hash。但代码很长，200+行。非常荣幸的1ac了！ #include #include #define MAX_LINES 2048#define MAX_LINE_LEN 128#define MAX_DOCS ... 阅读全文

糯米 2010-07-23 13:24 发表评论

POJ 1570 Exchange Rates 并查集

糯米 — Thu, 22 Jul 2010 03:59:00 GMT

并查集加上分数运算就可以了。
两种物品之间的兑换比率可以用分数来表示，两种物品之间是否存在联系用并查集来表示。

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

typedef struct {
    int a, b;
} frac ;

#define MAX_ITEM 64

char item[MAX_ITEM][32];
int item_cnt;

struct {
    frac f;
    int p;
} set[MAX_ITEM];

int gcd(int a, int b)
{
    int t;

    if (a > b) {
        a ^= b;
        b ^= a;
        a ^= b;
    }

    while (a) {
        t = a;
        a = b % a;
        b = t;
    }

    return b;
}

frac init(int a, int b)
{
    frac r;
    int g = gcd(a, b);

    r.a = a / g;
    r.b = b / g;

    return r;
}

frac mul(frac a, frac b)
{
    return init(a.a * b.a, a.b * b.b);
}

frac div(frac a, frac b)
{
    return init(a.a * b.b, a.b * b.a);
}

int find(int i)
{
    int p;

    if (set[i].p == i)
        return i;

    p = find(set[i].p);
    set[i].f = mul(set[set[i].p].f, set[i].f);
    set[i].p = p;

    return p;
}

int insert(char *s)
{
    int i;

    for (i = 0; i < item_cnt; i++)
        if (!strcmp(s, item[i]))
            return i;
    strcpy(item[item_cnt], s);
    return item_cnt++;
}

int main()
{
    char op[16], sa[32], sb[32];
    int a, b, ia, ib, i, p;
    frac f;

    for (i = 0; i < MAX_ITEM; i++) {
        set[i].p = i;
        set[i].f = init(1, 1);
    }

    while (scanf("%s", op), op[0] != '.') {
        if (op[0] == '!') {
            scanf("%d%s%*s%d%s", &a, sa, &b, sb);
            ia = insert(sa);
            ib = insert(sb);
            find(ia);
            p = set[ia].p;
            set[p].p = ib;
            set[p].f = div(init(b, a), set[ia].f);
        } else {
            scanf("%s%*s%s", sa, sb);
            ia = insert(sa);
            ib = insert(sb);
            find(ia);
            find(ib);
            if (set[ia].p == set[ib].p) {
                f = div(set[ia].f, set[ib].f);
                printf("%d %s = %d %s\n", f.b, item[ia], f.a, item[ib]);
            } else
                printf("? %s = ? %s\n", item[ia], item[ib]);
        }
    }

    return 0;
}

糯米 2010-07-22 11:59 发表评论

POJ 1432 Decoding Morse Sequences 动态规划＋hash

糯米 — Wed, 21 Jul 2010 06:27:00 GMT

思路如下：

匹配的递归过程如下。
把单词和正文都转换成mos码来表示。
从正文的头部开始匹配。
如果某个单词是正文的前缀，那么从前缀后面的部分递归下去。
统计一下所有方案的数目，就是答案了。
子问题就是“从位置k开始匹配，有多少种方案”，数组保存即可。

关键在于怎样快速发现某个单词是正文的前缀。
如果顺序查找，复杂度O(N)，超时。
如果枚举单词长度后二分查找，复杂度O(L*lgN)，应该不会超时，但代码不太自然，比较难写。
如果枚举单词长度后用hash查找，复杂度O(L)，不会超时，而且代码比较好写。

事实证明，经典的字符串hash函数同样可以用于mos码，在65536格的闭hash里面没有产生冲突！

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

char *mos[] = {
    ".-",
    "-",
    "-.-.",
    "-..",

    ".",
    "..-.",
    "--.",
    ".",

    "..",
    ".---",
    "-.-",
    ".-..",

    "--",
    "-.",
    "---",
    ".--.",

    "--.-",
    ".-.",
    "",
    "-",

    "..-",
    "-",
    ".--",
    "-..-",

    "-.--",
    "--..",
};

#define HASH_SIZE 65536
#define INPUT_LEN 10032

struct _hash {
    int val, cnt;
};

struct _hash hash[HASH_SIZE];
int dp[INPUT_LEN];
int max_len;

int strhash(char *str, int len)
{
    int val;
    for (val = 0; len--; str++)
        val = val*31 + *str;
    return val & 0x7fffffff;
}

struct _hash *find(int val)
{
    int h;

    for (h = val % HASH_SIZE;
         hash[h].cnt && hash[h].val != val;
         h = (h + 1) % HASH_SIZE
        );
    return &hash[h];
}

void insert(char *str)
{
    int len = strlen(str);
    int val = strhash(str, len);
    struct _hash *h = find(val);

//    printf("insert %s\n", str);

    if (len > max_len)
        max_len = len;

    h->val = val;
    h->cnt++;
}

int calc(char *str, int start)
{
    struct _hash *h;
    int i, s;

//    printf("start %d %s\n", start, str + start);

    if (!str[start])
        return 1;

    if (dp[start] != -1)
        return dp[start];

    s = 0;
    for (i = 1; str[start + i - 1] && i <= max_len; i++) {
        h = find(strhash(str + start, i));
//        printf("len %d %s cnt %d\n", i, str + start, h->cnt);
        if (h->cnt)
            s += calc(str, start + i) * h->cnt;
    }

    dp[start] = s;
    return s;
}

void solve()
{
    int i, j, d, n;
    static char word[32], str[256], in[10032];

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

    scanf("%s%d", in, &n);
    for (i = 0; i < n; i++) {
        scanf("%s", word);
        str[0] = 0;
        for (j = 0; word[j]; j++)
            strcat(str, mos[word[j] - 'A']);
        insert(str);
    }
//    printf("max_len %d\n", max_len);
    printf("%d\n", calc(in, 0));
}

int main()
{
    int d;

    scanf("%d", &d);
    while (d--)
        solve();

    return 0;
}

糯米 2010-07-21 14:27 发表评论

POJ 1434 Fill the Cisterns!

糯米 — Tue, 20 Jul 2010 13:48:00 GMT

回家待了几天，我觉得再继续颓废下去也不是个办法。还是得他妈的振作！振作！
跟以前一样，按照计划行事。
每天2题，难度随意。做不出来绝对不死磕，找标程或者数据弄懂再说。管他妈什么算法，我只管写代码。
项目紧的时候做项目，不紧的时候看点代码或者写点代码，啥都行，主要是保持一个感觉。
剩下的时间就练吉他。

今天开始做了第一题，结果悲剧。
我日你妈poj，能不能不要他妈的加数据，为啥子官方数据都过了还是过不了你那的。。

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

#define MAX_N 50032

int K, N, V;
struct node {
    int base, area, sign;
};

struct node arr[MAX_N*2];

int cmp(const void *a, const void *b)
{
    return ((struct node *)a)->base - ((struct node *)b)->base;
}

int main()
{
    int b, h, w, d, i, a, v;

    scanf("%d", &K);
    while (K--) {
        scanf("%d", &N);
        for (i = 0; i < N; i++) {
            scanf("%d%d%d%d", &b, &d, &w, &h);
            arr[i*2].base = b;
            arr[i*2].area = w * h;
            arr[i*2].sign = 1;
            arr[i*2 + 1].base = b + d;
            arr[i*2 + 1].area = w * h;
            arr[i*2 + 1].sign = -1;
        }
        scanf("%d", &V);
        qsort(arr, N*2, sizeof(arr[0]), cmp);

        a = 0;
        for (i = 0; i < N*2; i++) {
            v = i ? a * (arr[i].base - arr[i - 1].base) : 0;
            if (V <= v) {
                printf("%.2lf\n", (double)V / a + arr[i - 1].base);
                break;
            }
            V -= v;
            a += arr[i].sign * arr[i].area;
        }
        if (i == N*2)
            printf("OVERFLOW\n");
    }

    return 0;
}

糯米 2010-07-20 21:48 发表评论

POJ 1229 Wild Domains 动态规划

糯米 — Wed, 26 May 2010 00:21:00 GMT

摘要: 这题看上去很冷门~其实也是的，第一眼看上去想不到好的解法，但是将问题稍稍转化一下就很好办了。思路：两个pattern匹配的过程，如果没有通配符，那就是从左到右，逐个逐个的匹配。由于存在通配符，a的一个节点有可能匹配b的数个节点，同样，b的一个节点也有可能匹配a的数个节点。这就需要搜索了。但是一开始发现搜索的时候通配符的处理真的很麻烦。感觉就是代码稍微写错一点就会WA。于是想简化一下问题。重新定义三... 阅读全文

糯米 2010-05-26 08:21 发表评论

POJ 1226 Substrings 后缀Trie

糯米 — Wed, 26 May 2010 00:05:00 GMT

思路：

将每个字符串的原文的所有后缀和反转后的所有后缀都插入到Trie中。
同时Trie中的节点维护一个值 --- 该节点下面包含了多少个不同单词的节点。
然后统计这个值等于N的最深的节点，其深度就是答案了。
后缀Trie并不是好的解法。有人说用后缀数组也能做的，但是想不出来。

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

struct node {
    char ch;
    int ts, cnt;
    struct node *sib, *child;
};

struct node nodes[65536], root;
int nodes_cnt;
int N, T;
int ts, ans;

inline struct node *insert(struct node *q, char ch, int depth)
{
    struct node *t;

    for (t = q->child; t; t = t->sib)
        if (t->ch == ch)
            break;

    if (!t) {
        t = &nodes[nodes_cnt++];
        t->ch = ch;
        t->cnt = 0;
        t->child = NULL;
        t->sib = q->child;
        q->child = t;
    }

    if (t->ts != ts) {
        t->ts = ts;
        t->cnt++;
    }

    if (t->cnt == N && depth > ans)
        ans = depth;

    return t;
}

int main()
{
    int i, j, k, len;
    char str[128];
    struct node *t;

    scanf("%d", &T);
    while (T--) {
        scanf("%d", &N);
        ans = 0;
        nodes_cnt = 0;
        root.child = root.sib = NULL;
        root.cnt = 0;
        for (i = 0; i < N; i++) {
            scanf("%s", str);
            ts++;
            len = strlen(str);
            for (j = 0; j < len; j++) {
                t = &root;
                for (k = j; k < len; k++)
                    t = insert(t, str[k], k - j + 1);
            }
            for (j = len - 1; j >= 0; j--) {
                t = &root;
                for (k = j; k >= 0; k--)
                    t = insert(t, str[k], j - k + 1);
            }
        }
        printf("%d\n", ans);
    }

    return 0;
}

糯米 2010-05-26 08:05 发表评论

POJ 1230 Pass-Muraille 贪心

糯米 — Mon, 24 May 2010 15:20:00 GMT

思路：

考虑最左边的需要移除墙的列。这列是必定要移除一些墙的。
不妨移除右边界较大的那些墙。

实现的时候，可以用基数排序的方式来找到右边界较大的墙。
开两个数组如下：
map[i][j] = { 第i列中，从该列开始向右延伸，长度为j的墙的数目}
cnt[i] = {第i列中墙的数目}
这样代码比较方便，速度也快。

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

int T, N, K;
char map[128][128];
int cnt[128];

int main()
{
    int x1, x2, y;
    int i, j, i2, j2, ans;

    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &N, &K);
        memset(map, 0, sizeof(map));
        memset(cnt, 0, sizeof(cnt));
        while (N--) {
            scanf("%d%d%d%d", &x1, &y, &x2, &y);
            if (x1 > x2) {
                x1 ^= x2;
                x2 ^= x1;
                x1 ^= x2;
            }
            for (i = x1; i <= x2; i++) {
                map[i][x2 - i + 1]++;
                cnt[i]++;
            }
        }
        ans = 0;
        for (i = 0; i <= 100; i++) {
            if (cnt[i] <= K)
                continue;
            for (j = 100; cnt[i] > K && j > 0; j--) {
                while (cnt[i] > K && map[i][j]) {
                    i2 = i;
                    j2 = j;
                    while (j2) {
                        map[i2][j2]--;
                        cnt[i2]--;
                        j2--;
                        i2++;
                    }
                    ans++;
                }
            }
        }
        printf("%d\n", ans);
    }

    return 0;
}

糯米 2010-05-24 23:20 发表评论

POJ 1231 The Alphabet Game 贪心

糯米 — Mon, 24 May 2010 15:14:00 GMT

近来实验室给派了新活，跟原来做的东西，以及我们熟悉的东西都比较不搭边的，郁闷。
折腾了两个星期，昨天终于有了些进展。
今天做了两道水题~ 都是贪心

思路：
这题看上去挺唬人，提交的人也不多，实际上都是水题来的。
1. 对于同一种字母，求出它出现位置的最左边、最右边、最上边、最下边。这就构成了一个矩形。
2. 对于在x轴上投影重合的一系列矩形，他们必定处在同一个方格内。给这些方格编号。
3. 对于在y轴上投影重合的一系列矩形，如果其中两个编号相同，就不符合条件了。

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

using namespace std;

struct rect {
    int left, right, top, bottom;
    int rank_x;
} rec[32];
int T, K, P;

int cmp_x(const void *a, const void *b)
{
    return ((struct rect *)a)->left - ((struct rect *)b)->left;
}

int cmp_y(const void *a, const void *b)
{
    return ((struct rect *)a)->top - ((struct rect *)b)->top;
}

inline int solve()
{
    int i, last, rank, mask;

    qsort(rec, K, sizeof(rec[0]), cmp_x);
    rank = 0;
    for (i = 0; i < K; ) {
        last = rec[i].right;
        while (i < K && rec[i].left <= last) {
            rec[i].rank_x = rank;
            last = max(last, rec[i].right);
            i++;
        }
        rank++;
    }

    qsort(rec, K, sizeof(rec[0]), cmp_y);
    for (i = 0; i < K; ) {
        mask = 0;
        last = rec[i].bottom;
        while (i < K && rec[i].top <= last) {
            if (mask & (1 << rec[i].rank_x))
                return 0;
            mask |= 1 << rec[i].rank_x;
            last = max(last, rec[i].bottom);
            i++;
        }
    }

    return 1;
}

int main()
{
    int i, j, x, y;

    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &K, &P);
        for (i = 0; i < K; i++) {
            rec[i].left = rec[i].top = 1000000;
            rec[i].right = rec[i].bottom = 0;
            for (j = 0; j < P; j++) {
                scanf("%d%d", &x, &y);
                if (x < rec[i].left)
                    rec[i].left = x;
                if (x > rec[i].right)
                    rec[i].right = x;
                if (y < rec[i].top)
                    rec[i].top = y;
                if (y > rec[i].bottom)
                    rec[i].bottom = y;
            }
        }
        printf("%s\n", solve() ? "YES" : "NO");
    }

    return 0;
}

糯米 2010-05-24 23:14 发表评论

POJ 1171 Letter Game 背包

糯米 — Mon, 10 May 2010 13:37:00 GMT

思路：

它的要求是，给你几个字母，用这些字母拼几个字典里面有的单词，所有单词加起来求最高得分。
转化一下，就是个01背包问题。
由于单词的长度很短很短了，只有3~7个字母，所以总状态数很少啦。数组开到 2048 就可以AC了。

后来又搜了一下别人的解题报告哦，发现有个哥们很牛逼。
他说：单词长度范围在3--7内。所以可能的词组只能是 3+3 或 3+4

一语惊醒脑残人。太牛逼了！

代码 150ms AC。

#include <stdio.h>

char key[] = {
    "qwertyuiop"
    "asdfghjkl"
    "zxcvbnm"
};
int score[] = {
    7, 6, 1, 2, 2, 5, 4, 1, 3, 5,
    2, 1, 4, 6, 5, 5, 7, 6, 3,
    7, 7, 4, 6, 5, 2, 5
};

int map[256], col[256], idx[256], mul[8], tot[8], cnt, hash[2048], top;

int can_add(int a, int b)
{
    int i, ia, ib;

    for (i = 1; i < cnt; i++) {
        ia = (a / mul[i - 1]) % tot[i];
        ib = (b / mul[i - 1]) % tot[i];
        if (ia + ib >= tot[i])
            return 0;
    }

    return 1;
}

int main()
{
    int i, val, sum[256], sc;
    char str[16];

    freopen("e:\\test\\in.txt", "r", stdin);

    for (i = 0; i < 26; i++)
        map[key[i]] = score[i];

    scanf("%s", str);
    for (i = 0; str[i]; i++)
        col[str[i]]++;

    cnt = 1;
    for (i = 'a'; i <= 'z'; i++)
        if (col[i]) {
            idx[i] = cnt;
            mul[cnt] = tot[cnt] = col[i] + 1;
            cnt++;
        }

    mul[0] = 1;
    for (i = 1; i < cnt; i++)
        mul[i] *= mul[i - 1];
    top = mul[cnt - 1];
    hash[0] = 1;

    while (scanf("%s", str), str[0] != '.') {
        for (i = 'a'; i <= 'z'; i++)
            sum[i] = 0;
        sc = 0;
        val = 0;
        for (i = 0; str[i]; i++) {
            sum[str[i]]++;
            if (sum[str[i]] > col[str[i]])
                break;
            sc += map[str[i]];
            val += mul[idx[str[i]] - 1];
        }
        if (str[i])
            continue;
        for (i = top; i >= 0; i--) {
            if (!hash[i])
                continue;
            if (can_add(i, val) && hash[i + val] < hash[i] + sc)
                hash[i + val] = hash[i] + sc;
        }
    }

    sc = 0;
    for (i = top; i >= 0; i--)
        if (hash[i] > sc)
            sc = hash[i];
    printf("%d\n", sc - 1);

    return 0;
}

糯米 2010-05-10 21:37 发表评论

POJ 1187 陨石的秘密动态规划

糯米 — Thu, 06 May 2010 13:56:00 GMT

#include <stdio.h>

#define MOD(x) (((x) + 11380) % 11380)

int L1, L2, L3, D, f[11][11][11][31];

inline int part(int ma, int mb, int mc, int md,
                int a, int b, int c
                )
{
    return MOD(f[a][b][c][md - 1] * f[ma - a][mb - b][mc - c][md]);
}

inline int calc(int ma, int mb, int mc, int md)
{
    int a, b, c, r;

    if (!ma && !mb && !mc)
        return 1;

    r = 0;
    if (mc) {
        for (c = 0; c <= mc - 1; c++)
            r = MOD(r + part(ma, mb, mc - 1, md, 0, 0, c));
    }
    if (mb) {
        for (b = 0; b <= mb - 1; b++)
            for (c = 0; c <= mc; c++)
                r = MOD(r + part(ma, mb - 1, mc, md, 0, b, c));
    }
    if (ma) {
        for (a = 0; a <= ma - 1; a++)
            for (b = 0; b <= mb; b++)
                for (c = 0; c <= mc; c++)
                    r = MOD(r + part(ma - 1, mb, mc, md, a, b, c));
    }
    return r;
}

int main()
{
    int a, b, c, d;

    freopen("e:\\in.txt", "r", stdin);

    scanf("%d%d%d%d", &L1, &L2, &L3, &D);

    f[0][0][0][0] = 1;
    for (d = 1; d <= D; d++)
        for (a = 0; a <= L1; a++)
            for (b = 0; b <= L2; b++)
                for (c = 0; c <= L3; c++)
                    f[a][b][c][d] = calc(a, b, c, d);

    printf("%d\n", D ? MOD(f[L1][L2][L3][D] - f[L1][L2][L3][D - 1]) :
                       MOD(f[L1][L2][L3][D])
                );

    return 0;
}

思路：

把括号的嵌套看成是一棵树就简单点了。
这棵树的最大深度为 D。()节点下面不能有{}[]节点，[]节点下面不能有{}节点。
然后我们从上往下依次摆放节点。

考虑只有()节点的情况。
如果 f[n][d] 表示现在有n个节点需要摆放，深度小于等于d。
那么当前节点的下面可以摆 1，2 ... n 个节点。
摆完当前节点之后，剩下的在右边继续摆。
总方案数就是等于下面的方案数*右边的方案数

考虑三种节点都有的情况，实际上只是比上面的问题复杂一点点而已。
如果 f[a][b][c][d] 表示现在有a个{}节点，b个[]节点，c个()节点需要摆放。
当前节点摆 () 的时候，下面就只能摆 ()，其余的全放在右边。
当前节点摆 [] 的时候，下面就只能摆 ()[]，。。。
。。。

这题的复杂度是 O(L1*L1*L2*L2*L3*L3*D)。
看上去比较大，但是可以AC的~

之前自己想的方法是 f[a][b][c][d] 表示深度等于d的方案数，而不是小于。
最后答案为 f[L1][L2][L3][D]。
复杂度多乘了一个D，就TLE了。

后来看了别人方法，发现保存深度小于等于d，这样的话会好一些。
最后答案为 f[L1][L2][L3][D] - f[L1][L2][L3][D - 1]
这方法实在牛逼！

代码：

糯米 2010-05-06 21:56 发表评论

POJ 2009 Moo University - Emergency Pizza Order 无耻贪心解法

糯米 — Tue, 27 Apr 2010 06:25:00 GMT

这题能不能贪心，是很难说的。。
因为没有能什么证明贪心是对的，但也没找到什么反例。
代码写出来，WA了。
但总觉得是对的，因为吗的实在找不到反例。
结果找到数据测了下，果然十个过了九个。。
你看，如果这是NOIP，跟满分都没啥区别的对吧。我已经满足了。。
没过的那组，比较大，肉眼看不出是啥问题。
想了下，给排序加多了一个判断，然后那组数据就过了。。
然后提交，吗的还上榜了。。无语。

这样做比较无耻，网上有人说用最大流做，不理解。下次想一想。

思路：
如果牛喜欢的种类个数小于 K，那这种牛是无法满足的。。
把牛按照喜欢的种类个数排序，先处理小的。
就是用组合数枚举每一种可能的 pizza 情况。
用 hash 保存这些情况。

代码：

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

#define HASH_SIZE 65536

struct cow_node {
    int val, cnt;
};

int C, T, K, ans;
struct cow_node cows[1024];
int hash[HASH_SIZE];

int cmp(const void *a, const void *b)
{
    if (((struct cow_node *)a)->cnt == ((struct cow_node *)b)->cnt)
        return ((struct cow_node *)a)->val - ((struct cow_node *)b)->val;
    return ((struct cow_node *)a)->cnt - ((struct cow_node *)b)->cnt;
}

inline int insert(int val)
{
    int i, h;

    h = val & (HASH_SIZE - 1);
    for (i = h + 1; i != h && hash[i] && hash[i] != val; )
        i = (i + 1) & (HASH_SIZE - 1);
    if (i == h || hash[i] == val)
        return 0;
    hash[i] = val;
    return 1;
}

inline int calc(struct cow_node *t)
{
    int arr[32], map[32], i, j, val;

    for (i = j = 0; i < 32; i++)
        if (t->val & (1 << i))
            map[j++] = (1 << i);
    for (i = 0; i < K; i++)
        arr[i] = i;
    while (1) {
        val = 0;
        for (i = 0; i < K; i++)
            val |= map[arr[i]];
        if (insert(val))
            return 1;
        for (i = K - 1; i >= 0 && arr[i] == i + t->cnt - K; i--);
        if (i < 0)
            break;
        arr[i]++;
        for (i++; i < K; i++)
            arr[i] = arr[i - 1] + 1;
    }

    return 0;
}

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

    freopen("e:\\test\\in.txt", "r", stdin);

    scanf("%d%d%d", &C, &T, &K);
    for (i = 0; i < C; i++) {
        scanf("%d", &cows[i].cnt);
        cows[i].val = 0;
        for (j = 0; j < cows[i].cnt; j++) {
            scanf("%d", &k);
            k--;
            cows[i].val |= 1 << k;
        }
        if (cows[i].cnt < K) {
            i--; C--;
            continue;
        }
    }
    qsort(cows, C, sizeof(cows[0]), cmp);

    for (i = 0; i < C; i++)
        ans += calc(&cows[i]);
    printf("%d\n", ans);

    return 0;
}

糯米 2010-04-27 14:25 发表评论

POJ 2111 Millenium Leapcow 动态规划

糯米 — Tue, 27 Apr 2010 06:14:00 GMT

思路：

先按棋盘上的值从大到小排序。
然后先解决值大的，再解决值小的。
注意路径的比较。应该很容易WA的。

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

using namespace std;

#define MAX_N 512

struct seq_node {
    short y, x;
};
struct map_node {
    int val, cnt;
    struct map_node *pre;
};
struct map_node map[MAX_N][MAX_N], *ans;
struct seq_node seq[MAX_N*MAX_N];
int N;

int cmp_seq(const void *a, const void *b)
{
    return    map[((struct seq_node *)a)->y][((struct seq_node *)a)->x].val -
            map[((struct seq_node *)b)->y][((struct seq_node *)b)->x].val;
}

inline int cmp_path(struct map_node *a, struct map_node *b)
{
    while (a && b) {
        if (a->val != b->val)
            return a->val - b->val;
        a = a->pre;
        b = b->pre;
    }
    return 0;
}

inline void update(struct map_node *a, int y2, int x2)
{
    struct map_node *b = &map[y2][x2];

    if (y2 < 0 || y2 >= N || x2 < 0 || x2 >= N)
        return ;
    if (b->val > a->val &&
        (b->cnt > a->cnt || b->cnt == a->cnt && cmp_path(b, a->pre) < 0)
        )
    {
        a->cnt = b->cnt;
        a->pre = b;
    }
}

int main()
{
    int x, y, i;
    struct seq_node *t;
    struct map_node *m;

    freopen("e:\\test\\in.txt", "r", stdin);

    scanf("%d", &N);
    i = 0;
    for (y = 0; y < N; y++) {
        for (x = 0; x < N; x++) {
            scanf("%d", &map[y][x].val);
            seq[i].y = y;
            seq[i].x = x;
            i++;
        }
    }
    qsort(seq, N*N, sizeof(seq[0]), cmp_seq);

    for (t = &seq[N*N - 1]; t >= seq; t--) {
        m = &map[t->y][t->x];
        update(m, t->y - 2, t->x + 1);
        update(m, t->y + 2, t->x + 1);
        update(m, t->y - 2, t->x - 1);
        update(m, t->y + 2, t->x - 1);
        update(m, t->y - 1, t->x + 2);
        update(m, t->y + 1, t->x + 2);
        update(m, t->y - 1, t->x - 2);
        update(m, t->y + 1, t->x - 2);
        m->cnt++;
        if ((!ans || m->cnt > ans->cnt) ||
            (m->cnt == ans->cnt && cmp_path(m, ans) < 0)
            )
            ans = m;
    }

    printf("%d\n", ans->cnt);
    while (ans) {
        printf("%d\n", ans->val);
        ans = ans->pre;
    }

    return 0;
}

糯米 2010-04-27 14:14 发表评论