C++博客-Yuan-随笔分类-OJ解题报告

SRM 239 HiddenTriangles ★★★★

_Yuan — Sat, 12 Feb 2011 15:11:00 GMT

/*
    给出一些平行于axes或与坐标轴成45°的线段
    问其中有多少个三角形
    n <= 50  (x,y) ∈ [-100,100]

    不会做，一点想法都没有哎
    解题报告 http://www.topcoder.com/tc?module=Static&d1=match_editorials&d2=srm239
    规模比较小，直接枚举三条边
    但有个问题就是有些边可以连接起来，需要再处理

    范围比较小，可以放大两倍（处理对角线交点），然后进行标记，看哪些边是有线段的
    mark[x,y,d] 表示点(x,y)在方向d的单位长度上有线段覆盖
    这种记录方法很好！！！
    pLen[x,y,d]表示点(x,y)在方向d能延伸多长
    有了以上的预处理后
    统计时，枚举点(x,y)，方向d，还有长度len（由于题目的三角形都是等腰的，所以枚举长度即可）
    对于(x,y,d)，另外一条直角边就行(x,y,d+2)，斜边为(x,y,d+3)
    长度要判断一下，跟角度有关

    解题报告的代码写得真好！！
*/
#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>

using namespace std;

const int MAXN = 400;

int dx[] = {1,1,0,-1,-1,-1,0,1};
int dy[] = {0,1,1,1,0,-1,-1,-1};

bool mark[MAXN+1][MAXN+1][8];
int pLen[MAXN+1][MAXN+1][8];

class HiddenTriangles{
public:

    int sign(int x){∈
        return x < 0 ? -1 : x > 0 ;
    }

    void markIt(int x1,int y1,int x2,int y2){
        int d = 0;
        while(dx[d] != sign(x2-x1) || dy[d] != sign(y2-y1))d++;
        while(x1!=x2 || y1!=y2){// x1 = x2 && y1 = y2 , then break
            mark[x1][y1][d] = true;
            x1 += dx[d];
            y1 += dy[d];
            mark[x1][y1][(d+4)%8] = true;
        }
    }

    int calLen(int x ,int y , int d){
        if(pLen[x][y][d] == -1){
            if(mark[x][y][d])pLen[x][y][d] = 1 + calLen(x+dx[d],y+dy[d],d);
            else pLen[x][y][d] = 0;
        }
        return pLen[x][y][d];
    }

    void calLen(){
        memset(pLen , -1 , sizeof pLen);
        for(int x = 0 ; x <= MAXN ; x++)
            for(int y = 0 ; y <= MAXN ; y++)
                for(int d = 0 ; d < 8 ; d++)
                    pLen[x][y][d] = calLen(x,y,d);
    }

    int count(){
        int ans = 0;
        for(int x = 0 ; x <= MAXN ; x ++)
            for(int y = 0 ; y <= MAXN ; y++)
                for(int d = 0 ; d < 8 ; d++){
                    for(int len = 1 ;;len++){
                        if(pLen[x][y][d] < len || pLen[x][y][(d+2)%8] < len)break;
                        int side = d % 2 == 0 ? 1 : 2;  // parallel to axes : form a 45 degree angle
                        if(pLen[x+dx[d]*len][y+dy[d]*len][(d+3)%8] >= len*side)ans++;
                    }
                }
        return ans;
    }

    int howMany(vector <int> X1, vector <int> Y1, vector <int> X2, vector <int> Y2){
        memset(mark,false,sizeof mark);
        int n = X1.size();
        for(int i = 0 ; i < n ; i++){
            markIt(2*X1[i]+200,2*Y1[i]+200,2*X2[i]+200,2*Y2[i]+200);//extend it
        }
        calLen();
        return count();
    }

};

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

CodeForces 59E 以边为状态bfs ★★★★

_Yuan — Sat, 12 Feb 2011 12:39:00 GMT

/*
    一个无向图，n<=3000 , m <= 20000
    有k个限制，表示a->b->c不能走， k<= 10^5
    求1到n的最短路，不能走过有限制的地方

    我猜是bfs，但是不会做，我的思维局限在状态是在顶点上，这样是不够记录的
    如a->b->a，两个a的状态值是不同的

    看了watashi的，DIY群上有人说是以边为状态

    dp[pre][now]表示从1到pre->now这条边经过的花费
    枚举now的非限制的邻接边扩展
    对于判重问题通过去掉边来做
    it = E[u].erase(it)
    这样下次就不会走了   神奇丫！！！！！！！！！！！！

    存限制时是用map,set > mp
    这样存(a,b,c)比起弄两个pair好多了！！！

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

using namespace std;

const int MAXN = 10086;
const int INF = 1000000000;

list<short> E[3001];
map<pair<short,short> , set<short> > mp;//(a,b,c)
int dp[3001][3001] ;
short pre[3001][3001];

void print(int last , int now){
    if(last == -1)return;
    print(pre[last][now] , last);
    printf("%d ",last);
}

int main()
{
    for(int n , m, k;~scanf("%d%d%d",&n,&m,&k);){
        for(int i = 1 ; i <= n; i ++){
            E[i].clear();
        }
        int a,b,c;
        for(int i = 0 ; i < m ; i++){
            scanf("%d%d",&a,&b);
            E[a].push_back(b);
            E[b].push_back(a);
        }
        mp.clear();
        for(int i = 0 ; i < k ; i++){
            scanf("%d%d%d",&a,&b,&c);
            mp[make_pair(a,b)].insert(c);
        }

        fill(dp[1],dp[n+1],INF);

        queue<pair<short,short> > Q;
        for(list<short>::iterator it = E[1].begin() ; it != E[1].end() ; it++){
            dp[1][*it] = 1;
            pre[1][*it] = -1;
            Q.push(make_pair(1,*it));
        }
        E[1].clear();
        while(!Q.empty()){
            pair<short,short> p = Q.front();
            Q.pop();
            a = p.first;
            b = p.second;
            set<short> &iset = mp[p];
            for(list<short>::iterator it = E[b].begin() ; it != E[b].end();){
                if(iset.count(*it) > 0){
                    it++;
                }
                else{
                    dp[b][*it] = dp[a][b] + 1;
                    pre[b][*it] = a;
                    Q.push(make_pair(b,*it));
                    it = E[b].erase(it);//处理判重！！
                }
            }
        }

        int ans = INF , ansPre;
        for(int i = 1 ; i < n ; i++){
            if(dp[i][n] < ans){
                ans = dp[i][n];
                ansPre = i;
            }
        }

        if(ans == INF)puts("-1");
        else{
            printf("%d\n",ans);
            print(ansPre,n);
            printf("%d\n",n);
        }
    }
    return 0;
}

_Yuan 2011-02-12 20:39 发表评论

TCO'10 Wildcard Round 500pt CalculationCards

_Yuan — Thu, 10 Feb 2011 06:47:00 GMT

/*
    n<=50张卡如3张：+1 ,-2 , *3  其排列有
    0 + 1 - 2 * 3 = -5
    0 + 1 * 3 - 2 = 1
    0 - 2 + 1 * 3 = 1
    0 - 2 * 3 + 1 = -5
    0 * 3 + 1 - 2 = -1
    0 * 3 - 2 + 1 = -1
    期望为-1.6666666666666667
    求给定的n张卡的期望值

    看解题报告http://www.topcoder.com/wiki/display/tc/TCO'10+Wildcard+Round
    以及bmerry代码的

    不可能n!的枚举
    设+、-卡共有s张
    按照一个+、-卡后接连续的*卡分类，则有s部分，其全排列不影响期望（总共s!种，但期望都一样）
    所以只考虑无序的（无序可以用默认的一种顺序，即卡出现的先后顺序，或者说编号）
    ***a1***a2***  as***
    ***表示*卡
    由于是等概率的，所以总体来统计，每个+、-卡都会接同样的*卡，
    既然每张+、-卡情况一样，那就考虑a1卡
    其后会接0,1,m张*卡
    答案就是 sum * (0,1,m)张*卡的期望   sum = ∑ai
    求k张*卡的期望可以用dp做
    看bmerry代码的做法，解题报告的麻烦一点吧
    一开始只有s张a卡排着，然后插入一张张*卡
    dp[i,j]表示插入了前面i张*卡，a1后接j张*卡，它们构成的期望值
    分第i张卡插不插入到a1之后构成j张连续的*卡，概率为该插入的位置/总位置
    dp[i,j] =
                dp[i-1,j] * (n-j-1)/n
            + m[i]*dp[i-1,j-1] * j/n
    n为s+i

    这道题一个很好的想法就是答案为sum * (0,1,m)张*卡的期望   sum = ∑ai   ！！！！！！
    而求后接k张*卡的期望，bmerry的做法是一张一张卡插入，然后求得期望
    小规模到大规模，通过考虑插入位置来实现，这个做法应该较好
*/
#include<cstdio>
#include<algorithm>
#include<vector>
#include<iostream>
#include<cstring>
#include<string>

using namespace std;

class CalculationCards{

public:

    double getExpected(vector <string> cards){
        vector<int> mults;
        int sum = 0;
        for(vector <string>::iterator it = cards.begin() ; it != cards.end() ; it++){
            string str = *it;
            if(str[0] == '*')
                mults.push_back(str[1]-'0');
            else sum += atoi(str.c_str());
        }

        int m = mults.size() , n = cards.size() - m;
        cout<<m<<" "<<n<<" "<<sum<<endl;

        //dp[i,j]前面i个mul选j个的期望
        double dp[60][60] = {0.0};
        dp[0][0] = 1.0;
        for(int i = 1 ; i <= m ; i++){
            cout<<i<<":\n";
            n++;
            dp[i][0] = dp[i-1][0]*(n-1)/n;
            cout<<dp[i][0];
            for(int j = 1; j <= i ; j++)
            {
                dp[i][j] =
                    dp[i-1][j]*(n-j-1)/n
                    + mults[i-1]*dp[i-1][j-1]*j/n;
                cout<<" "<<dp[i][j];
            }
            cout<<endl;
        }

        double tot = 0;
        for(int k = 0 ; k <= m ; k++)
            tot += dp[m][k];
        return sum * tot;
    }

};

_Yuan 2011-02-10 14:47 发表评论

zoj 3462 bitset

_Yuan — Tue, 08 Feb 2011 08:07:00 GMT

/*
    n<=1024个文件每个文件有一些tag，以及文件大小
    q<=8192个询问求同时满足这些tag的文件的大小之和

    我的写法超时
    看了watashi的用bitset，哇，这么好写，而且又快。。。
    bitset : set(pos) , retset(pos) , retset() , &
*/
#include<cstdio>
#include<cstring>
#include<map>
#include<algorithm>
#include<bitset>
#include<string>

using namespace  std;

long long size[1024];
char str[100000];

int main()
{

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

    for(int n , q ; ~scanf("%d",&n) ; )
    {
        map<string,bitset<1024> > mp;
        bitset<1024> mask;

        for(int i = 0 ; i < n ; i++)
        {
            scanf("%s%lld",str,&size[i]);
            char *beg = str , *end;
            while((beg = strchr(beg,'[')) != NULL)
            {
                end = strchr(beg , ']');
                mp[string(beg+1,end)].set(i);
                beg = end;
            }
        }

        scanf("%d",&q);
        while(q--)
        {
            scanf("%s",str);
            for(int i = 0 ; i < n ; i ++)
                mask.set(i);
            char *beg = str , *end;
            while((beg = strchr(beg,'[')) != NULL)
            {
                end = strchr(beg , ']');
                map<string,bitset<1024> >::iterator it = mp.find(string(beg+1,end));
                if(it == mp.end())
                {
                    mask.reset();
                    break;
                }
                else mask &= it->second;
                beg = end;
            }

            long long ans = 0;//会超int
            for(int i = 0 ; i < n ; i ++)
            {
                if(mask[i])
                    ans += size[i];
            }
            printf("%lld\n",ans);
        }
    }
    return 0;
}

_Yuan 2011-02-08 16:07 发表评论

SRM 496 PalindromfulString 容斥写法 ★★★★

_Yuan — Thu, 03 Feb 2011 07:36:00 GMT

摘要: /**//* 问长度为N的字符串(uppercase)中，至少有K个长度为M的回文串的个数 N<=11 一开始我在那里dp推，发现有重复之类的东西不好搞看了Sevenkplus的，容斥，感觉好神奇... 阅读全文

_Yuan 2011-02-03 15:36 发表评论

CodeForces 57D

_Yuan — Fri, 28 Jan 2011 18:09:00 GMT

摘要: /**//* 题意：n,m的网格，有一些static particles，规定任意两个不能在同一行、列，不能在相邻的对角线 A dynamic particle选择非static的cell作为起点和终点，然后从起点选择最短路径走到终点（不经过 ... 阅读全文

_Yuan 2011-01-29 02:09 发表评论

CodeForces 55D 数位统计记忆化搜索跟pre有关 ★★★★

_Yuan — Sun, 23 Jan 2011 17:43:00 GMT

/*
    a positive integer number is beautiful if and only if it is divisible by each of its nonzero digits.
    问一个区间内[l,r]有多少个Beautiful数字
    范围9*10^18

    数位统计问题，构造状态也挺难的，我想不出，我的思维局限在用递推去初始化状态，而这里的状态定义也比较难
    跟pre的具体数字有关

    问了NotOnlySuccess的，豁然开朗  Orz

    一个数字要被它的所有非零位整除，即被他们的LCM整除，可以存已有数字的Mask，但更好的方法是存它们的LCM{digit[i]}
    int MOD = LCM{1,2,9} = 5 * 7 * 8 * 9 = 2520
    按照定义，数字x为Beautiful ：
    x % LCM{digit[xi]} = 0
    即 x % MOD % LCM{digit[xi]} = 0
    所以可以只需存x % MOD，范围缩小了
    而在逐位统计时，假设到了pre***（pre指前面的一段已知的数字，而*是任意变）
        ( preSum * 10^pos + next )  % MOD % LCM(preLcm , nextLcm)
    =  ( preSum * 10 ^ pos % MOD + next % MOD ) % LCM(preLcm , nextLcm)
    == 0
    而next，nextLcm是变量，上面的比较式的意义就是
    在已知pos , preSum , preLcm情况下有多少种(next,nextLcm)满足式子为0
    而这个就是一个重复子问题所在的地方了，需要记录下来，用记忆化搜索
    dfs(pos , preSum , preLcm , doing)
    加一个标记为doing表示目前是在计算给定数字的上限，还是没有上限，即***类型的
    这样就将初始化以及逐位统计写在一个dfs了，好神奇！！！

    还有一点，10以内的数字情况为2^3 , 3^2 , 5 , 7
    所以最小公倍数组合的情况只有4*3*2*2 = 48
    可以存起来，我看NotOnlySuccess的写法是
    for(int i = 1 ; i <= MOD ; i ++)
    {
        if(MOD % i == 0)
            index[i] = num++;
    }
    很棒！！

    所以复杂度大概为19*2520*48*10（状态数*决策数）

    我觉得这题状态的设计不能跟具体数字分开，否则会很难设计吧
    所以用记忆化搜索，存起来
    用具体数字去计算，重复的子问题跟pre关系比较密切
    有一个比较重要的切入点就是LCM，还有%MOD缩小范围，才能存储

    还有优化到只需%252的，更快
    不过我觉得%2520比较好理解
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<cstdio>

using namespace std;

const int MOD = 2520;

__int64 dp[19][MOD][48];
int index[MOD+10];
int digit[19];

int gcd(int a , int b)
{
    return b == 0 ? a : gcd(b , a % b);
}

int lcm(int a, int b)
{
    return a / gcd(a,b) * b;
}

void init()
{
    //编号
    int num = 0;
    for(int i = 1 ; i <= MOD ; i ++)
    {
        if(MOD % i == 0)
            index[i] = num ++;
    }
    memset(dp,-1,sizeof(dp));
}

__int64 dfs(int pos , int preSum , int preLcm , bool doing)
{
    if(pos == -1)//为一个数字时
        return preSum % preLcm == 0;

    if(!doing && dp[pos][preSum][index[preLcm]] != -1)
        return dp[pos][preSum][index[preLcm]];

    __int64 ans = 0;
    int end = doing ? digit[pos] : 9;
    for(int i = 0 ; i <= end ; i++)//上界
    {
        int nowSum = (preSum * 10 + i ) % MOD;
        int nowLcm = preLcm;
        if(i)
        {
            nowLcm = lcm(nowLcm , i);
        }
        ans += dfs(pos - 1 ,  nowSum , nowLcm , doing && i == end);//doing && i == end
    }

    if(!doing)
    {
        dp[pos][preSum][index[preLcm]] = ans;
    }

    return ans;
}

__int64 cal(__int64 x)
{
    int pos = 0;
    while(x)
    {
        digit[pos++] = x % 10;
        x /= 10;
    }
    return dfs(pos - 1 , 0 , 1 , 1);
}

int main()
{
    init();
    int T;
    for(scanf("%d",&T) ; T -- ; )
    {
        __int64 left , right ;
        cin >> left >> right;
        cout << cal(right) - cal(left - 1) << endl;
    }
    return 0;
}

_Yuan 2011-01-24 01:43 发表评论

CodeForces 55E Very simple problem

_Yuan — Sat, 22 Jan 2011 07:11:00 GMT

/*
    给出一个凸多边形n<=100000，t个询问
    每个询问，问凸多边形有多少个三角形包含点(x,y)

    看解题报告的
    O(n)算法
    总三角形个数 - 不包含(x,y)的三角形个数

    代码看 252170    Ra16bit
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<string>

using namespace std;

const int INF = 1000000000;
const int MAXN = 100010;

struct Point
{
    double x ,y;
    void read()
    {
        scanf("%lf%lf",&x,&y);
    }
};

Point pt[MAXN*2];

double cross(Point A , Point B , Point O)
{
    return (A.x - O.x) * (B.y - O.y) - (A.y - O.y) * (B.x - O.x);
}

int main()
{
    //freopen("in","r",stdin);
    for(int n;~scanf("%d",&n);)
    {
        for(int i = 0 ; i < n ; i ++)
        {
            pt[i].read();
            pt[i+n] = pt[i];
        }

        int t;
        scanf("%d",&t);
        while(t--)
        {
            Point xy;
            xy.read();
            bool flag = false;
            for(int i = 0 ; i < n ; i ++)
            {
                if(cross(pt[i+1] , xy ,  pt[i] ) >= 0 )
                {
                    flag = true;
                    break;
                }
            }

            if(flag)
            {
                puts("0");
                continue;
            }

            __int64 ans = (__int64)n*(n-1)*(n-2)/6;//C(n,3)

            for(int i = 0 , j = 2 ; i < n ;  i++)
            {
                while(cross( xy,pt[j] , pt[i]) > 0)
                {
                    j++;
                }
                ans -= (__int64)(j-1-i)*(j-1-i-1)/2;//C(j-1-i , 2)
            }
            printf("%I64d\n",ans);
        }
    }
    return 0;
}

_Yuan 2011-01-22 15:11 发表评论

zoj 3455 统计出现次数判断相等用l[i]记录字母出现i次的个数 ★★★★

_Yuan — Thu, 20 Jan 2011 06:09:00 GMT

/*
    可以对P串进行替换和交换，问T串有多少位置跟P是匹配的 n<=500000

    统计下各个字母出现的次数，判断是否相等就可以了
    但是要写得好，O(n)
    我写得不好，参考watashi的
    他用l[i]记录字母出现i次的个数
    一开始先存P的l[]数组
    然后对于T的字母，判断能否抵消，如果能全部抵消，即k=m，就匹配了
    抵消，即l[]全部为0了
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<cstdio>

using namespace std;

const int MAXN = 500500;
const int SIGMA = 256;

char T[MAXN] , P[MAXN];
int l[MAXN] , c[SIGMA];

int main()
{
    while(~scanf("%s%s",T,P))
    {
        int n = strlen(T);
        int m = strlen(P);

        fill(c,c+SIGMA,0);
        for(int i= 0 ; i < m ; i ++)
            c[P[i]]++;
        fill(l+1,l+1+m,0);
        for(int i = 0 ; i < SIGMA ; i ++)
            l[c[i]]--;//

        int k = count(l+1,l+1+m,0);

        vector<int>ans;

        fill(c,c+SIGMA,0);
        for(int i = 0 ; i < n ; i ++)
        {
            if(i>=m)//del
            {
                int &cc = c[T[i-m]];

                if(l[cc] == 0)k--;
                else if(l[cc] == 1)k++;
                l[cc]--;

                cc--;
                if(cc!=0)
                {
                    if(l[cc] == -1)k++;
                    else if(l[cc] == 0)k--;
                    l[cc]++;
                }
            }

            //add
            int &cc = c[T[i]];
            if(cc!=0)
            {
                if(l[cc] == 0)k--;
                else if(l[cc] == 1)k++;
                l[cc]--;
            }

            cc++;
            if(l[cc] == -1)k++;
            else if(l[cc] == 0)k--;
            l[cc]++;

            if(k==m)
            {
                ans.push_back(i-m+1);
            }
        }

        if(ans.empty())
        {
            puts("No");
        }
        else
        {
            puts("Yes");
            for(int i  = 0 ; i < ans.size() ; i ++)
            {
                if(i)
                    putchar(' ');
                printf("%d",ans[i]);
            }
            puts("");
        }
    }
    return 0;
}

_Yuan 2011-01-20 14:09 发表评论

zoj 3354 映射环计数 ★★★

_Yuan — Wed, 19 Jan 2011 14:06:00 GMT

/*
        给出一种映射f,问一个序列经过任意次映射的复合，问能得到多少种不同的文本
        "he may encrypt the letter for several times. "
        here may be ai=aj when i≠j. 不是一一映射

        如果是一一映射的，就是一个一个的环了（因为出度、入度为 1）

        看watashi的
        这题就变成环引出尾巴出来了
        答案就成了：max{x[i]} + LCM{y[i]}
        x[i]为尾巴长度，y[i]为环长度

        注意求x[],y[]数组的方法，用栈

        而求LCM时，要分解质因子才行
        因为LCM(a%MOD,b%MOD) != LCM(a,b)%MOD
*/

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<stack>
#include<map>

using namespace std;

const int MAXN  = 1 << 17;

int p[MAXN];

void init()
{
    for(int i = 2 ; i < MAXN ; i ++)
    {
        if(p[i] != 0 )continue;
        for(int j  = i ; j < MAXN;  j += i )
        {
            p[j] = i;
        }
    }
}

struct LCM
{
    static const long long MOD = 1000000007LL;

    map<int,int>mp;

    void feed(int x)
    {
        while(x>1)
        {
            int p = ::p[x];
            int c = 0;
            do
            {
                x /= p;
                c ++;
            }while(x%p==0);
            mp[p] = max(mp[p],c);
        }
    }

    long long lcm()
    {
        long long ret = 1;
        for(map<int,int>::iterator it = mp.begin() ; it !=  mp.end() ; it++)
        {
            for(int i =0 ; i < it->second ; i ++)
                ret *= it->first;
            ret %= MOD;
        }
        return ret;
    }

};

int a[MAXN] , x[MAXN] , y[MAXN];

int main()
{
    init();
    int n,p,q;
    while(~scanf("%d",&n))
    {
        for(int i = 0 ; i < n ; i ++)
        {
            scanf("%d",&a[i]);
            x[i] = y[i] = -1;
        }
        for(int i = 0 ; i < n ; i  ++)
        {
            if(x[i]!=-1)
                continue;

            stack<int>s;
            p = i ;
            while(true)
            {
                x[p] = s.size();
                s.push(p);
                q = a[p];
                if(x[q] != -1)
                {
                    if(y[q] == -1)//circle
                    {
                        int loop = x[p] - x[q] + 1;
                        for(int i = 0 ; i < loop ; i ++)
                        {
                            p = s.top();
                            s.pop();
                            x[p] = 0;
                            y[p] = loop;
                        }
                    }
                    //else  non-circle
                    break;
                }
                else
                {
                    p = q;
                }
            }
            while(!s.empty())
            {
                p = s.top();
                s.pop();
                x[p] = x[a[p]]+1;
                y[p] = y[a[p]];
            }
        }

        LCM lcm;
        int base = 0;

        scanf("%d",&n);
        for(int i = 0 ;i < n ;  i++)
        {
            scanf("%d",&p);
            base = max(base , x[p]);
            lcm.feed(y[p]);
        }
        printf("%lld\n" , (base + lcm.lcm())%LCM::MOD);
    }
    return 0;
}

_Yuan 2011-01-19 22:06 发表评论

zoj 3436 逆推搜

_Yuan — Sat, 25 Dec 2010 13:07:00 GMT

/*
    题意：问一个区间内July Number的个数，区间范围10^9
              一个数，如890，不断求相邻位差，790->29->7
              如果最后为7，则该数为July Number

      看了watashi的，从7逆推，他的代码写得很好

      不用存前置0的，只需存答案即可
      比如7，用来生成长度为3的时候，7可看做07
      只需
      delta = difference/ten[n-1];
      difference -= delta*ten[n-1];
      就能看做有前置0了

      枚举长度
           枚举第一个数字
                枚举所有可以到达7的difference
                        dfs ，每次+- difference相应位的值
*/
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<map>

using namespace std;

int ten[] =
{
    1,
    10,
    100,
    1000,
    10000,
    100000,
    1000000,
    10000000,
    100000000,
};

vector<int> rec(1,7);//
vector<int> vc;

void dfs(int n , int difference , int x , int pre)
{
    pre = pre*10 + x;
    if(n==0)
    {
        vc.push_back(pre);
        return;
    }
    int delta = difference/ten[n-1];
    difference -= delta*ten[n-1];
    if(x-delta>=0)dfs(n-1,difference,x-delta,pre);
    if(x+delta<=9)dfs(n-1,difference,x+delta,pre);
}

void init()
{
    for(int len = 2 ; len <= 9 ; len++)
    {
        vc.clear();
        for(int first = 1 ; first <= 9 ; first++)
        {
            for(vector<int>::iterator it = rec.begin() ; it != rec.end() ; it++)
            {
                dfs(len-1, *it , first , 0);
            }
        }
        rec.insert(rec.end() , vc.begin() , vc.end());
        sort(rec.begin() , rec.end());
        rec.erase(unique(rec.begin(),rec.end()) ,  rec.end());
    }
//    cout<
}

int main()
{
    init();
    int a , b;
    while(cin>>a>>b)
    {
        cout<<upper_bound(rec.begin() , rec.end() , b) -  lower_bound(rec.begin() , rec.end() ,a)<<endl;
    }
    return 0;
}

_Yuan 2010-12-25 21:07 发表评论

foj 1988 二分+一点数学 ∑k除i.cpp

_Yuan — Sat, 25 Dec 2010 11:55:00 GMT

/*
    题意：定义f(k)为k的因子个数，G(k) = f(1) + .. + f(k)
              求一个k，使得G(k) = M   M<=10^9

    容易知道G(k) = 有因子1的数的个数 +
                            有因子2的数的个数 +

                            有因子k的数的个数
                         = k/1 +ｋ/2 +  k/k

    求G(k) = M ，可二分
    但计算G(k)用O(n)算法的话会超时
    我一开始TLE

    http://hi.baidu.com/aekdycoin/blog/item/16138adfd696844594ee370a.html
    提到
    由于整除，必然导致 [X / i]的值呈区间的形式出现
    例如X = 100
    X / 51 = 1
    X / 52 = 1

    X / 100 = 1


     才回忆起有一种快速的方法计算 k/1 + k/2 + .. + k / k
                                    next                        now
    i        1  |  2|    3|    4|    5    6|    7    8    9    10     11     12
    k/i        12    |  6|    4|    3|    2    2|    1    1    1    1      1        1
    对于值为val的，其个数为now-next
    O(sqrt(n))
    val = k / now
    next = k / (val+1) ，下一个val至少为val+1

    poj 2800是求∑k%i
*/
#include<cstdio>
#include<algorithm>
#include<vector>
#include<iostream>
#include<cmath>

using namespace std;

*
    int G(int k)
    {
        int sum = 0 ;
        for(int i = 1 ; i <= k ; i ++)
            sum += k/i;
        return sum;
    }
*/

int G(int k)
{
    int sum  = 0 ;
    int now = k , next , val;
    while(now > 0)
    {
        val = k / now;
        next = k / (val+1);
        sum += val*(now -next);
        now = next;
    }
    return sum;
}

int solve(int M)
{
    int low = 1 , high = 55592635;//G(55592635) > 10^9
    while(low <= high)
    {
        int mid = (low+high)>>1;
        int g = G(mid);
        if(g==M)return mid;
        if(g>M)high = mid-1;
        else low = mid+1;
    }
    return -1;
}

int main()
{
//    freopen("in","r",stdin);
    int T , t = 1;
    for(scanf("%d",&T) ; T--  ; )
    {
        int M , ans;
        scanf("%d",&M);
        printf("Case %d: ",t++);
        ans = solve(M);
        if(ans == -1)puts("impossible!");
        else printf("%d\n",ans);
    }
    return 0;
}

_Yuan 2010-12-25 19:55 发表评论

acm 2010 福州赛区 I Let the light guide us

_Yuan — Wed, 22 Dec 2010 05:07:00 GMT

摘要: /**//* 题意：n行m列 n<=100 , m<=5000 每一个位置有值T[i][j] , F[i][j] &... 阅读全文

_Yuan 2010-12-22 13:07 发表评论

2010 Fzu warm up D

_Yuan — Wed, 24 Nov 2010 10:18:00 GMT

   这题当时搞不出，是问了CrazyBoy的，超级膜拜。他的代码超级漂亮
   题意：给出一个无向图n<=12 ，一些节点已经着了颜色，问用k<=12种颜色对图染色的方案数（相邻点不能同色）

   他是用Dp做的，前i种颜色染整个图的方案数
   转移是枚举一个集合染第i种颜色

/*
    2010 Fuzhou Warm up
    D grap coloring
    Author : CrazyBoy (Jin Bin)
*/

#include<cstdio>
#include<cstring>

int color[12];
int G[12];

long long wys[1 << 12] , nwys[1 << 12];

int main()
{
    int T , n , m , colors;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d", &n, &m, &colors);
        memset(G, 0, sizeof(G));
        memset(color, 0, sizeof(color));
        for(int i = 0 ; i < n ; i++)
        {
            int nowc;
            scanf("%d", &nowc);
            if(nowc != 0 )
            {
                nowc --;
                color[nowc] |= 1 << i;
            }
        }
        for(int i = 0; i < m ; i ++)
        {
            int a, b ;
            scanf("%d%d",&a, &b);
            G[a] |= 1 << b;
            G[b] |= 1 << a;
        }

        int MASK = (1 << n) - 1;
        memset(wys, 0, sizeof(*wys) << n );
        wys[0] = 1;
        for(int i = 0; i < colors; i ++)
        {
            memset(nwys, 0, sizeof(*nwys) << n );
            for(int msk = 0; msk <= MASK; msk ++)
            {
                if(~msk & color[i])
                    continue;
                bool found = false;
                for(int j = 0; j < n; j ++)
                    if(msk >> j & 1 && msk & G[j])
                    {
                        found = true;
                        break;
                    }
                if(found)
                    continue;
                int MASK2 = MASK ^ msk;
                int j = 0;
                do {
                    nwys[j | msk] += wys[j];
                }while(j = j - MASK2 & MASK2);
            }
            memcpy(wys, nwys, sizeof(*wys) << n);
        }
        printf("%lld\n",wys[MASK]);
    }
    return 0;
}

_Yuan 2010-11-24 18:18 发表评论

zoj 3164

_Yuan — Thu, 18 Nov 2010 05:27:00 GMT

摘要: /**//* 题意：给出一些物品，有价值，数量，价格还有一些限制，限制的组里面只能选一种物品，问D钱最多能获得的价值按组分阶段，然后根据物品数量分别做0-1,完全，多重背包(logn) 之前做的都是一维数组的背包... 阅读全文

_Yuan 2010-11-18 13:27 发表评论

zoj 3159 二分全排列注意飞的时间可以为0 ★★★

_Yuan — Thu, 18 Nov 2010 02:39:00 GMT

/*
    题意：n只鸟在n个位置(n<=9)  一个人可以按一定顺序放鸟，放完一只后需要休息时间t
    才能放下一只，问最少的时间使得这些鸟都在一个地方碰头
    给出鸟的速度范围，x方向<=vx , y方向<=vy

    由于n<=9 全排列枚举顺序
    然后二分时间T，而一只鸟飞行的范围就是
    [x-vx*t',x+vx*t'],[y-vy*t',y+vy*t']
    t' = max(T-(i-1)*t , 0)  注意这里可以取0，即不飞行！！！
*/
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const double EPS = 1e-8;//1e-6 is also ok

struct Point
{
    double x,y;
    int id;
    void read()
    {
        scanf("%lf%lf",&x,&y);
    }
    bool operator < (const Point &B)const
    {
        return id < B.id;
    }
};

Point pt[10];
int n , vx , vy ,t;

bool chk(double endTime)
{
    double xMin = -1e30 , yMin = -1e30;
    double xMax = 1e30 , yMax = 1e30;
    double left = endTime;

    for(int i = 0 ; i < n ; i++)
    {
        double _xMin = pt[i].x - left*vx , _yMin = pt[i].y - left*vy;
        double _xMax = pt[i].x + left*vx , _yMax = pt[i].y + left*vy;

        xMin = max(xMin , _xMin);
        xMax = min(xMax , _xMax);
        if(xMin > xMax + EPS)return false;

        yMin = max(yMin , _yMin);
        yMax = min(yMax , _yMax);
        if(yMin > yMax + EPS)return false;

        left -= t;

        if(left < 0)left = 0;//需要这样子！！有些鸟可以不用飞出去
    }
    return true;
}

int main()
{
    //freopen("in","r",stdin);

    while( ~scanf("%d%d%d%d",&n,&vx,&vy,&t) )
    {
        for(int i = 0; i < n ; i++)
        {
            pt[i].read();
            pt[i].id = i;
        }

        double ans = 1e30;
        do
        {
            int cnt = 0;
            double low = 0, high = 1e10;
            //if(chk(high)==false) continue;    high is absolutely ok , not need to check
            while(high - low > EPS && cnt < 100)
            {
                double mid = (high + low)/2;
                if(chk(mid))high = mid;
                else low = mid;
                cnt ++;
            }
            ans = min(ans,high);

        }while(next_permutation(pt,pt+n));

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

_Yuan 2010-11-18 10:39 发表评论

zoj 3161 ★★★

_Yuan — Wed, 17 Nov 2010 15:13:00 GMT

/*
    一开始题目看的不是很懂，看watashi的解题报告的

    题意：n个团员，坐成一排。团长列出m对关系，
    每分钟报一个，如果关系中的两个人相邻，则其中一个人要离开
    团员想走的越多越好，团长想走的人越少越好，问团长该怎么安排
    这m对关系的顺序

    显然团长可以先贪心地把原本不相邻的关系先报掉，这样没人会走
    接下来的就是一些连续的一段
    这个问题可以dp预处理，dp[n]表示n个人连成一段最少离开的人数

    团长会枚举断开的点然后缩小规模解决
    1 - 2 - 3  n-1 - n
    枚举断开第i段的话，现在团员当然会选择让离开的人最多
    即 max(dp[i-1]+dp[n-i]+1 , dp[i]+dp[n-i-1]+1)
    而团长就通过枚举哪一段来取得最小值
    min{ max(dp[i-1]+dp[n-i]+1 , dp[i]+dp[n-i-1]+1) }
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>

using namespace std;

const int INF = 1000000000;

int dp[512];

void init()
{
    dp[2] = 1;
    for(int n = 3 ; n <= 500 ; n++)
    {
        dp[n] = INF;
        for(int i = 1 ; i < n ; i++)
        {
            dp[n] = min( dp[n] , max(dp[i-1]+dp[n-i] , dp[i]+dp[n-i-1])+1 );
        }
    }
}

int main()
{
    //freopen("in","r",stdin);
    init();
    int n , m;
    while(~scanf("%d%d",&n,&m) )
    {
        int a ,b;
        vector<int> vt;
        for(int i = 0 ; i < m ; i++)
        {
            scanf("%d%d",&a,&b);
            if(a>b)swap(a,b);
            if(b==a+1)
            {
                vt.push_back(a);
            }
        }
        sort(vt.begin() , vt.end());
        int ans = n;
        for(vector<int>::iterator it = vt.begin() ; it != vt.end();it++)
        {
            int cnt = 1;
            while( it+1 != vt.end() && (*it)+1 == *(it+1))cnt++,it++;
            cnt ++;
            ans -= dp[cnt];
        }
        printf("%d\n",ans);
    }
    return 0;
}

_Yuan 2010-11-17 23:13 发表评论

zoj 3416 统计 ★★★★

_Yuan — Sun, 14 Nov 2010 13:41:00 GMT

摘要: /**//* 一个数是Balanced ，指这个数的力矩为0 如 4139 选支点为3 4*2 + 1*1 = 9*1 为[x,y]内有多少个Balanced... 阅读全文

_Yuan 2010-11-14 21:41 发表评论

zoj 3289 ★★★★ 矩阵乘法周期

_Yuan — Sat, 13 Nov 2010 03:43:00 GMT

摘要: /**//* 给出一个图，询问T时间内from->to的方法数。t<=10^9 ， n<=50 但每个点向外的边有周期性，在某些时刻会开，某些时刻没有周期<=6 人可在点停留&n... 阅读全文

_Yuan 2010-11-13 11:43 发表评论

tju 3750 枚举边连接两颗子树的重心 ★★★

_Yuan — Fri, 12 Nov 2010 15:55:00 GMT

摘要: /**//* 题意：给出一棵树，现可以移动一条边，问怎么移动使得最长边最小 n <= 2500 比赛时脑残，一点想法都没有 &nb... 阅读全文

_Yuan 2010-11-12 23:55 发表评论

hdu 3593 泛化背包 O(NC) ★★★

_Yuan — Fri, 12 Nov 2010 12:26:00 GMT

/*
    题意：有依赖的背包，要用树dp
    《浅谈几类背包题》里提到的《金明的预算方案》类似

    代码参照这里写的：http://hi.baidu.com/darkgtbd/blog/item/4bca2b16d955624420a4e9dc.html

    1<=N<=100000, 1<=G<=10000  数据很恐怖
    题目有个地方要注意到：
    3.  The alpc who has underling is an officer (Every officer’ number is no more than 500, like alpc21, alpc32).
    也就是说非叶子节点最多有500个    所以只需开dp[500][G]即可

    按照论文的方法，泛化背包合并，从O(NC^2) 用类似01背包的方法降到 O(NC)
    u对儿子v  dfs之前，先对dp[v][j]初始为dp[u,j]+val[v]  即强制放进去v  然后修改对v的上限
    最后合并，即更新

*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<cmath>
#include<cstdlib>
#include<iostream>

using namespace std;

const int INF = 1000000000;
const int MAXN = 100010;

struct Edge
{
    int v;
    Edge *next;
};

Edge *E[MAXN] , edges[MAXN*2] , *pE;

bool leaf[MAXN];
int weight[MAXN] , val[MAXN];
int dp[505][10005];

inline void add(int u,int v)
{
    pE->v = v;
    pE->next = E[u];
    E[u] = pE++;
}

void dfs(int u, int C)
{
    for(Edge *it = E[u] ; it ; it = it->next)
    {
        int v = it->v;
        if(!leaf[v])
        {
            for(int j = 0 ; j <= C-weight[v]; j++)//强制放进去v
                dp[v][j] = dp[u][j] + val[v];
            dfs(v,C-weight[v]);//修改上限
            for(int j = weight[v] ; j <= C ; j++)//两者合并   对于dp[v,j]只有j<=C-weight[v]时才是正确的结果
                if(dp[u][j] < dp[v][j-weight[v]])
                    dp[u][j] = dp[v][j-weight[v]];
        }
        else
        {
            for(int j = C ; j >= weight[v] ; j--)
                if(dp[u][j] < dp[u][j-weight[v]] + val[v])
                   dp[u][j] = dp[u][j-weight[v]] + val[v];
        }
    }
}

int main()
{

#ifdef ONLINE_JUDGE
#else
    freopen("in", "r", stdin);
#endif

    int n ,g , f ;
    while( ~scanf("%d%d",&n,&g) )
    {
        pE = edges;
        for(int i = 0 ; i <= n ; i++)
        {
            E[i] = NULL;
            leaf[i] = true;
        }
        weight[0] = val[0] = 0;

        for(int i = 1; i <= n ;i++)
        {
            scanf("%d%d%d", &weight[i] , &val[i] , &f );
            if(f == i)f = 0;
            leaf[f] = false;
            add(f,i);
        }

        for(int i = 0 ;i <= g ; i++)
            dp[0][i] = 0;
        dfs(0,g);

        int ans = 0;
        for(int j = 0 ; j <= g; j++)
            if(ans < dp[0][j])
                ans = dp[0][j];
        printf("%d\n",ans);
    }
    return 0;
}

_Yuan 2010-11-12 20:26 发表评论

Pku Campus 2010

_Yuan — Thu, 11 Nov 2010 16:31:00 GMT

摘要: 今天下午，我们队做了Pku Campus 2010，还算可以4个1y，做了6题，罚时挺少的。过了A,C,D,E,G,H ^_^ A 我当时找规律的，发现有递推式，然后得推O(1)公式才能过... 1Y Poj 3761 找规... 阅读全文

_Yuan 2010-11-12 00:31 发表评论

zoj 3353 高斯消元二进制枚举 ★★★

_Yuan — Thu, 11 Nov 2010 02:07:00 GMT

摘要: /**//* 4种模式，问选哪种模式，使得棋盘变为0而且开关个数最少 watashi博客说可以贪心，枚举第一行、列（与pattern有关！！！）然后去判断是否无解、唯一解他也提供了一种高斯消元做，然后再二进制枚举... 阅读全文

_Yuan 2010-11-11 10:07 发表评论

zoj 3372 模拟★★★ 类似dij

_Yuan — Wed, 10 Nov 2010 08:21:00 GMT

摘要: /**//* 一个矩形，分成几块小矩形，每个小矩形有深度其中某个矩形会有水不断流入，问填满所有矩形所需的时间一个矩形填满后会外溢，每条边的速度跟边长成比例我一开始不敢写，没想到很清晰的思路 ... 阅读全文

_Yuan 2010-11-10 16:21 发表评论

hdu 3341 ac自动机 dp ★★★★

_Yuan — Wed, 10 Nov 2010 03:58:00 GMT

摘要: /**//* 题意：给出一些病毒串，一个原串，问怎么调整原串的顺序使得跟最多的病毒串匹配抄解题报告：自动机+DP。设主串有na个A、nc个C、ng个G、nt个T，于是题意转化为用na个A、 nc个C、ng个G、n... 阅读全文

_Yuan 2010-11-10 11:58 发表评论

zoj 3293 数位统计

_Yuan — Mon, 08 Nov 2010 14:55:00 GMT

/*
    序列 2 4 4 6 8 8 8 10 12 12 14
    即每一项都是偶数，而且复制k次，a[i] = b*2^k   b%2 != 0

    列一下，发现有规律
    a[2^k - 1] 是最后一个 2^k
    写一下二进制表示，发现当前段（按k划分段）的总和可用到之前的结果
    定义dp[k]表示a[1]到第k段结束之和
    如dp[1] = a[1]
    dp[2] = a[1] + a[2] + a[3]

    dp[k] = a[1] +  + a[2^k - 1]
    这个可以预处理出来

    然后对于一个x，要得到sum[x] 用逐位统计去做
*/
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

long long dp[32];

void init()
{
    dp[1] = 2;
    for(int i = 2; i <= 31 ; i++)
    {
        dp[i] = 2*dp[i-1] + ((1LL<<i-1)+1)*(1LL<<i-1);
    }
}

long long cal(long long x)
{
    if(x==0)return 0;
    int k = 0 ;
    while( (1LL<<k) <= x ) k++;
    long long k2 = 1LL<<k;

    if(k2-x <= k)//在最后k个数中
    {
        return dp[k] - (k2-1-x)*k2;
    }

    return dp[k-1]+(x-k2/2 + 1)*(k2/2) + cal(x-k2/2+1);
}

int main()
{
    init();
    long long x, y;
    while( ~scanf("%lld %lld",&x,&y) )
    {
        printf("%lld\n",cal(y)- cal(x-1));
    }
    return 0;
}

_Yuan 2010-11-08 22:55 发表评论

zoj 3369 状态表示得很好 ★★★★

_Yuan — Mon, 08 Nov 2010 13:42:00 GMT

/*
   抄watashi  他太无敌了    状态表示得很好  写得很好！！！！！

   题意：要救公主，但要一关一关过去
        人初始有 h , s , p , m值
        每一关可以攻击D 或睡眠E 敌人
        D : 需要 s >= s[i]              攻击后 h - = max(2s[i] - s , 0) , s++
        E : 需要 m >= m[i] , p >= p[i]  睡眠后 m -= m[i] , p++
        h = 0 时死掉

   要注意到，前面i次用了j次攻击D的话，肯定有 i - j 次睡眠E
   而且每D一次 s++ , 每E一次 p++
   所以用 dp[i,j,k] 记录前面搞定i个敌人用了j次攻击，剩余k个魔法的最大血量
   当为j时，显然s = s0 + j , p = p0 + (i-j)

   这样子用3维就能表示出了   其余的可以推出的
   Orz

   "转移的时候要注意可干性和可睡性的判断。"  ^_^

*/
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int MAXN = 52;

int dp[MAXN][MAXN][MAXN];
char pre[MAXN][MAXN][MAXN];

int s[MAXN] , p[MAXN] , m[MAXN];

int main()
{

   // freopen("in","r",stdin);

    int n , h , pp , ss ,mm;
    char ans[100];

    while( ~scanf("%d%d%d%d%d" , &n ,& h ,&ss ,&pp , &mm) )
    {

        for(int i = 0 ; i <= n ; i++)
            for(int j = 0 ; j <= n ; j++)
                for(int k = 0 ; k <= mm ; k++)
                {
                    dp[i][j][k] = 0;
                }

        for(int i = 0 ; i < n;  i++)
        {
            scanf("%d%d%d",&s[i],&p[i],&m[i]);
        }

        dp[0][0][mm] = h;
        for(int i = 0 ; i < n ; i++)
            for(int j = 0; j <= i ;j++)
                for(int k = 0; k <= mm ; k++)
                {
                    if(dp[i][j][k] == 0)continue;

                    //D : h - max(2si-s,0) , s++   | s>=si
                    //E : m - mi , p++             | p >= pi , m >= mi

                    int t = 2*s[i] - (ss+j);
                    if(t < 0) t  = 0;
                    if(ss+j >= s[i] && dp[i+1][j+1][k] < dp[i][j][k] - t)
                    {
                        dp[i+1][j+1][k] = dp[i][j][k] - t;
                        pre[i+1][j+1][k] = 'D';
                    }

                    t = pp + (i-j);
                    if(t >= p[i] && k >= m[i] && dp[i+1][j][k-m[i]] < dp[i][j][k])
                    {
                        dp[i+1][j][k-m[i]] = dp[i][j][k];
                        pre[i+1][j][k-m[i]] = 'E';
                    }
                }

        int J = -1 , K;
        for(int j = 0 ; j <= n && J == -1 ; j ++)
            for(int k = 0; k <= mm ; k++)
            {
                if(dp[n][j][k])
                {
                    J = j ;
                    K = k;
                    break;
                }
            }

        if(J == -1)puts("UNLUCKY");
        else
        {
            ans[n] = 0;
            for(int i = n-1 ; i >= 0; i--)
            {
                ans[i] = pre[i+1][J][K];
                if(ans[i] == 'D') J--;
                else K += m[i];
            }
            puts(ans);
        }
    }
    return 0;
}

_Yuan 2010-11-08 21:42 发表评论

zoj 3364 类似多边形面积计算 ★★★

_Yuan — Mon, 08 Nov 2010 12:34:00 GMT

/*
   题意：一个无限的棋盘，黑白相间，现画出一个多边形，问黑白格子的数目，多边形的边是平行于x,y轴

   抄watashi   Orz
   用类似求多边形的面积的方法

   对一个处于第一象限的矩形，要求面积的话，可以对平行于y轴的边处理，答案就是外边的边跟y轴形成的区域
   减去内边的边跟y轴形成的区域
   而求跟y皱形成的区域可用原点第一个点形成的区域  －   原点第二个点形成的区域

   对于其他象限，发现面积的符号就是x,y坐标的符号相乘！！！
   - +
   + -

   而对于原点跟(x,y)形成区域的黑格子，x,y坐标为正的就是所有奇数＊奇数＋偶数＊偶数的格子
   若其中有坐标为负，就将该坐标的奇数改为偶数

   好神奇
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<map>
#include<vector>

const int INF = 1000000000;
const int MAXN = 10086;

inline int odd(int x)
{
    return x >= 0 ? (x+1)/2 : x/2;
}

inline int even(int x)
{
    return x - odd(x);
}

#define gao()\
{\
   if(y1 == y2)\
   {\
     all += (long long)x1*y1;\
     b += (long long)odd(x1)*odd(y1) + (long long)even(x1)*even(y1);\
     all -= (long long)x2*y2;\
     b -= (long long)odd(x2)*odd(y2) + (long long)even(x2)*even(y2);\
   }\
}\

int main()
{

#ifdef ONLINE_JUDGE
#else
    freopen("in","r",stdin);
#endif
    int n;
    while( ~scanf("%d",&n) )
    {
        int x0 , y0 , x1, y1 , x2 , y2;
        long long all = 0 , b = 0;
        scanf("%d%d",&x0,&y0);
        x1 = x0;
        y1 = y0;
        for(int i = 1 ; i < n; i++)
        {
            scanf("%d%d",&x2,&y2);
            gao();
            x1 = x2;
            y1 = y2;
        }
        x2 = x0;
        y2 = y0;
        gao();
        printf("%lld %lld\n",b , all-b);
    }
    return 0;
}

_Yuan 2010-11-08 20:34 发表评论

zoj 3305 挺不错的01背包 ★★★

_Yuan — Sun, 07 Nov 2010 16:57:00 GMT

/*
    题意：n种材料，m种方案，每种方案会选择一些物品做出产品，问最多能
           做出多少种产品，但材料只能使用一次

    比较特别的01背包
    看二进制位，就是背包容量了，方案会占据一些位（或者说容量）
    用01背包更新即可
    这里二进制枚举补集的子集

    不是很快 600ms
    方案很多重复、包含
    可以先去重，还有去掉一些包含的，然后会快很多， 200多ms吧
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<cmath>
#include<cstdlib>
#include<iostream>

using namespace std;

const int INF = 1000000000;
const int MAXN = 10010;

int dp[1<<16];

int main()
{

#ifdef ONLINE_JUDGE
#else
    freopen("in", "r", stdin);
#endif

    int n , m;
    while( ~scanf("%d%d",&n,&m) )
    {
        int limit = (1<<n);
        fill(dp,dp+limit,0);
        for(int i = 0 ; i < m ; i++)
        {
            scanf("%d",&n);
            if(n==0)continue;//
            int mask = 0 , x;
            for(int j = 0 ; j < n ; j++)
            {
                scanf("%d",&x);
                mask |= (1<<x-1);
            }
            dp[mask] = max(dp[mask] , 1);
            int _mask = mask ^ (limit-1);//补集
            for(int j = _mask ; j ; j = (j-1) & _mask)
            {
                dp[mask | j] = max(dp[mask | j] , dp[j] + 1);
            }
        }
        printf("%d\n" , *max_element(dp,dp+limit) );
    }
    return 0;
}

_Yuan 2010-11-08 00:57 发表评论

hdu 3340 树状数组 + 一点几何

_Yuan — Sun, 07 Nov 2010 15:51:00 GMT

摘要: /**//* 有一些多边形掉下来，要询问区间[A,B]内掉下来的多边形的面积看解题报告的： “我们过每一个出现的横坐标做和y轴平行的竖直线，那么天上掉下来的多边形就被切割成一个一个的梯形（三角形可以看... 阅读全文

_Yuan 2010-11-07 23:51 发表评论