C++博客-acronix-随笔分类-hzshuai解题报告

poj3301（三分）

acronix — Sat, 13 Nov 2010 13:35:00 GMT

来源与分析：http://chenjianneng3.blog.163.com/blog/static/128345126201033101044920/

因为是求极值，所以要注意所求的数据范围，特别是最大，最小可能值。

2010 成都赛区的 Error Curves 就是典型的三分：

附上我的程序：

#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 10010;
const double eps = 1e-8;
double a[maxn],b[maxn],c[maxn];
int n;

double cal(double x)
{
    double s = -1e100,tmp;//注意s的要尽量小
    for (int i = 1; i <= n; i++)
    {
        tmp = a[i]*x*x + b[i]*x + c[i];
        s = max(tmp,s);
    }
    return s;
}

void solve()
{
    double left = 0.0, right = 1000.0;
    double mid, midmid;
    double mid_v, midmid_v;
    while (left + eps < right)
    {
        mid = (left + right) / 2;
        midmid = (mid + right) / 2;
        mid_v = cal(mid);
        midmid_v = cal(midmid);
        if (mid_v < midmid_v)
            right = midmid;
        else left = mid;
    }
    printf("%.4lf\n",cal((left+right)/2));
}

int main()
{
    int t,i,j;
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d",&n);
        for (i = 1; i <= n; i++)
            scanf("%lf %lf %lf",&a[i],&b[i],&c[i]);
        solve();
    }
    return 0;
}

某某程序：

#include <cstdio>
#include <algorithm>

using namespace std;

const int MAXN = 10086;
double a[MAXN], b[MAXN], c[MAXN];

int main() {
    int re, n;
    double l, r, m1, m2, y1, y2;

    scanf("%d", &re);
    for (int ri = 1; ri <= re; ++ri) {
        scanf("%d", &n);
        for (int i = 0; i < n; ++i) {
            scanf("%lf%lf%lf", &a[i], &b[i], &c[i]);
        }
        l = 0;
        r = 1000;
        while (r - l > 1e-8) {
            m1 = (l * 2 + r) / 3;
            m2 = (l + r * 2) / 3;
            y1 = y2 = -1e100;
            for (int i = 0; i < n; ++i) {
                y1 = max(y1, (a[i] * m1 + b[i]) * m1 + c[i]);
                y2 = max(y2, (a[i] * m2 + b[i]) * m2 + c[i]);
            }
            if (y1 < y2) {
                r = m2;
            } else {
                l = m1;
            }
        }
        l = (l + r) / 2;
        r = -1e100;
        for (int i = 0; i < n; ++i) {
            r = max(r, (a[i] * l + b[i]) * l + c[i]);
        }
        printf("%.4lf\n", r);
    }

    return 0;
}

三分法小结：只要解在一点范围内满足凸函数性质就行，通俗点说就是两边夹，从两边不断逼近。

模版化：

double Cal(Type a)
{
    /* 根据题目的意思计算 */
}

void Solve(void)
{
    double Left, Right;
    double mid, midmid;
    double mid_value, midmid_value;
    Left = MIN; Right = MAX;
    while (Left + EPS < Right)
    {
        mid = (Left + Right) / 2;
        midmid = (mid + Right) / 2;
        mid_value = Cal(mid);
        midmid_value = Cal(midmid);
        // 假设求解最大极值.
        if (mid_value >= midmid_value) Right = midmid;
        else Left = mid;
    }
}

poj3301cpp代码：

#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;

const double PI = acos(-1.0);
const double eps = 1e-8;
const double maxn = 1000;
int n;
double x[35],y[35];

double cal(double a)
{
    double  bx ,by ,sx,sy;
    bx = by = -maxn ,sx = sy = maxn;
    double tx,ty;
    for (int i = 1; i <= n; i++)
    {
         //tx，ty为坐标变换后的坐标，具体怎么推得忘了？？？？
        tx = x[i] * cos(a) - y[i] * sin(a);
        ty = y[i] * cos(a) + x[i] * sin(a);
        
        bx = max(tx,bx);
        sx = min(tx,sx);
        
        by = max(ty,by);
        sy = min(ty,sy);
    }
    return max(bx - sx , by - sy);
}

int main()
{
    int t,i,j;
    double lf,rt;
    double m1,m2;
    double m1_v,m2_v;
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d",&n);
        for (i = 1; i <= n; i++)
            scanf("%lf %lf",&x[i],&y[i]);
        lf = 0.0; rt = PI/2;
        while (lf + eps < rt)
        {
            m1 = (lf + rt) / 2;
            m2 = (m1 + rt) / 2;
            m1_v = cal(m1);
            m2_v = cal(m2);
            if (m1_v <= m2_v)
                rt = m2;
            else lf = m1;
        }
        double len = cal(lf);
        printf("%.2lf\n",len*len);
    }
    return 0;
}

acronix 2010-11-13 21:35 发表评论

poj3294(后缀数组，dc3)

acronix — Fri, 12 Nov 2010 16:09:00 GMT

摘要: 题目描述：给定n 个字符串，求出现在不小于k 个字符串中的最长子串。解题报告：将n 个字符串连起来，中间用不相同的且没有出现在字符串中的字符隔开，求后缀数组。然后二分答案，将后缀分成若干组，判断每组的后缀是否出现在不小于k 个的原串中。注意： 1、题目要求是超过一半有最大的公共子串，即》 N / 2，并且 N = 1时直接输出； &n... 阅读全文

acronix 2010-11-13 00:09 发表评论

poj3067Japan（树状数组求逆序对）

acronix — Fri, 29 Oct 2010 07:23:00 GMT

题意：自己看吧。

分析：对左边的点从小到大排序，相等则对右边的从小到大排，最后只要求左边的逆序对即可，求逆序对除了树状数组还有归并排序。

注意：边可以达到1000*1000，结果会超int。

cpp代码：

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

int maxn,n,m,k;
struct Point{
    int x,y;
}a[1000010];
long long c[1005];

int Lowbit(int i)
{
    return i&(-i);
}

long long up(int x)
{
    int i = x;
    long long res = 0;
    while (i <= maxn)
    {
        res += c[i];
        i += Lowbit(i);
    }
    return res;
}

void down(int x)
{
    int i = x;
    while (i > 0)
    {
        c[i]++;
        i -= Lowbit(i);
    }

}


bool cmp(const Point &a,const Point &b)
{
    if (a.x == b.x)
        return a.y < b.y;
   return a.x < b.x;
}

int main()
{
    int t,cas = 1,i;
    long long ans;
    scanf("%d ", &t);
    while (t--)
    {
        ans = 0;
        scanf("%d %d %d",&n,&m,&k);
        for (i = 1; i <= m; i++)
            c[i] =  0;
        maxn = m;
        for (i = 1; i <= k; i++)
        {
            scanf("%d %d",&a[i].x, &a[i].y);
        }
        sort(a+1, a+1+k, cmp);
        for (i = 1; i <= k; i++)
        {
            ans += up(a[i].y + 1);
            down(a[i].y);
        }
        printf("Test case %d: %I64d\n",cas++, ans);

    }

    return 0;
}

acronix 2010-10-29 15:23 发表评论

poj2481cows（树状数组）

acronix — Fri, 29 Oct 2010 07:18:00 GMT

题意：给每只cow的头尾坐标，求对于每只cow比他壮的cow，壮大的定义就是比他长就是比他壮。

分析：二维变一维，先按左边的坐标按 j 从大到小排列，然后是 i 左边的坐标从小到大，最后处理 i 就行了，跟stars一样。

cpp代码：

#include <cstdio>
#include <stdlib.h>
#include <algorithm>
#include <memory.h>
using namespace std;

int maxn;
int c[100010];
struct Cow{
    int s,e;
    int id;
}cow[100010];
int cnt[100010];
int n;

bool cmp(const Cow &a,const Cow &b)
{
    if (a.e == b.e)
        return a.s < b.s;
    return a.e > b.e;
}

int Lowbit(int i)
{
    return i&(-i);
}

void up(int x)
{
    int i = x;
    while (i <= n)
    {
        c[i] += 1;
        i += Lowbit(i);
    }
}

int down(int x)
{
    int i = x , res = 0;
    while (i > 0)
    {
        res += c[i];
        i -= Lowbit(i);
    }
    return res;
}


int main()
{
    int i,x,y;
    while (scanf("%d",&n) && n)
    {
        maxn = 0;
        memset(c,0,sizeof(c));
        for (i = 1; i <= n ;i++)
        {
            cnt[i] = 0;
            scanf("%d %d",&x,&y);
            cow[i].s = x+1 , cow[i].e = y+1;
            cow[i].id = i;
            if (maxn < cow[i].e)
                maxn = cow[i].e;
        }
        sort(cow+1,cow+1+n,cmp);

        for (i = 1; i <= n;i++)
        {
            if (i > 1 && cow[i].s == cow[i-1].s && cow[i].e == cow[i-1].e)
                cnt[cow[i].id] = cnt[cow[i-1].id];
            else cnt[cow[i].id] = down(cow[i].s);
            up(cow[i].s);
        }

        for (i = 1; i <= n; i++)
        {
            if (i != 1)
                printf(" ");
            printf("%d",cnt[i]);
        }
        printf("\n");

    }
    return 0;
}

acronix 2010-10-29 15:18 发表评论

poj1195Mobile phones（二维树状数组）

acronix — Fri, 29 Oct 2010 07:05:00 GMT

题意：给一个二维矩阵，边修改点格的手机的改变数目，边查询区间手机的总数目。

分析：就是Matrix的相反操作。

CPP代码：

#include <iostream>
#include <cstdio>
using namespace std;
int n;
int c[1030][1030];

int Lowbit(int i)
{
    return i&(-i);
}

void up(int x,int y,int a)
{
    int i = x,j;
    while (i <= n)
    {
        j = y;
        while (j <= n)
        {
            c[i][j] += a;
            j += Lowbit(j);
        }
        i += Lowbit(i);
    }
}

int down(int x,int y)
{
    int i = x,j,res = 0;
    while (i > 0)
    {
        j = y;
        while (j > 0)
        {
            res += c[i][j];
            j -= Lowbit(j);
        }
        i -= Lowbit(i);
    }
    return res;
}

int main()
{
    int ins,x,y,x1,y1,a;
    int i,j;
    scanf("%d %d",&ins,&n);
    for (i = 1; i <= n; i++)
        for (j = 1; j <= n; j++)
          c[i][j] = 0;
    while (1)
    {
        scanf("%d",&ins);
        if (ins == 3)
            break;
        if (ins == 1)
        {
            scanf("%d %d %d",&x,&y,&a);
            x++,y++;
            up(x,y,a);
        }
        if (ins == 2)
        {
            int ans = 0;;
            scanf("%d %d %d %d",&x,&y,&x1,&y1);
            x++,y++,x1++,y1++;
            ans = down(x1,y1) - down(x1,y-1) - down(x-1,y1) + down(x-1,y-1);
            printf("%d\n",ans);
        }

    }
    return 0;
}

acronix 2010-10-29 15:05 发表评论

pojMatrix 树状数组必做题目

acronix — Fri, 29 Oct 2010 06:58:00 GMT

题意：自己看吧。

分析：终于通过这道题弄懂了树状数组。

            首先这里我不具体解释 int Lowbit（） { i + （- i ) }  来源，我只想强调的是数组C【i】保存的是C[i - 2^k +1] 到C[i] 区间的状态，k 值是 i 二进制表示中末尾0的个数。

           我的理解就是树状数组有两种操作down ，up，都是对区间状态的操作，或者点状态的操作，注意一点的就是只是状态（包括简单的和，个数的

统计，本题翻转次数的统计）的查询与修改。树状数组的结构就是多叉树形结构，up（即 i + Lowbit(i)）是逐级向上处理父区间(注意我说的是父区间)，

down （即：i - Lowbit（i））要注意的是 down 不是逐级向下找子区间并进行操作，而是找左边相邻的兄弟区间（我不知道这样描述准不准确，

你可以看那张经典的树状数组的结构图再自己算算就很明了了）。正因为这样，树状数组能方便的查询父区间（UP操作），而不能方便的访问子区间，

只能方便访问左边相邻的兄弟区间（down操作），我觉得这就是它相对于线段树的不足之处，不过还是很强大的了。

           所以，当遇到具体的问题时，只要记住只是区间状态（和，个数，翻转次数。。。。）的访问，具体的操作是用down还是up就很好理解了。

          对于本题，change时是对区间段的翻转次数进行修改所以是down（依次向左对兄弟区间进行修改），当Query时，其实就是统计点覆盖点（x，y）各区间的总翻转次数所以是向上（up）查询父区间的过程，你可以自己模拟一下就很明了。

实现的CPP代码如下：

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

#define N 1005
int mat[N][N];
int n;

int lowbit(int key){
    return key&(-key);
}

int getsum(int x, int y){
    int ans = 0;
    for(int i=x; i<=n; i+=lowbit(i))
        for(int j=y; j<=n; j+=lowbit(j))
            ans = (ans+mat[i][j])%2;
    return ans;
}


void change(int x, int y){
    for(int i=x; i>0; i-=lowbit(i))
        for(int j=y; j>0; j-=lowbit(j))
            mat[i][j] = (mat[i][j]+1)%2;
}



int main(){
    int t;
    char si[10];
    scanf("%d",&t);
    while(t--){
        int m;
        scanf("%d%d",&n,&m);
        memset(mat,0,sizeof(mat));
        for(int i=0; i<m; i++){
            scanf("%s",si);
            if(si[0]=='C'){
                int x1,y1,x2,y2;
                scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
                change(x2,y2);
                change(x1-1,y2);
                change(x2,y1-1);
                change(x1-1,y1-1);
            }else{
                int x1,y1;
                scanf("%d%d",&x1,&y1);
                printf("%d\n",getsum(x1,y1));
            }
        }
        printf("\n");
    }
    return 0;
}

acronix 2010-10-29 14:58 发表评论

poj1151 Atlantis 标准的矩阵面积并

acronix — Fri, 29 Oct 2010 06:17:00 GMT

具体的就不多解释了，当线段树练练手吧。

#include <cstdio>
#include <stdlib.h>
#include <cmath>
#include <algorithm>
using namespace std;

const int root = 0;
const double eps = 1e-8;
struct Node{
       int l,r,cover;
       int lnd,rnd;
       double len;
}node[10000];
int cnt,cnty;
double indx[210];

struct Line{
     double  x,y1,y2;
     bool f;
}line[210];

void Creat(int p,int l,int r)
{
     node[p].l = l; node[p].r = r;
     node[p].len = 0.0; node[p].cover = 0;
     if (r - l > 1)
     {
           int mid = (l + r) >> 1;
           node[p].lnd = ++cnt;
           Creat(cnt,l,mid);
           node[p].rnd = ++cnt;
           Creat(cnt,mid,r);
     }
     else {node[p].lnd = node[p].rnd = -1;}
}

void upData(int p)
{
     if (node[p].cover > 0)
     {
         node[p].len = indx[node[p].r] - indx[node[p].l];
     }
     else if (node[p].l == node[p].r - 1)
          {
             node[p].len = 0.0;
             node[p].cover = 0;
          }
          else {
                 int lf = node[p].lnd;
                 int rf = node[p].rnd;
                 node[p].len = node[lf].len + node[rf].len;
               }
}

void Insert(int p,int l,int r)
{
   //  printf("p = %d,[%d,%d]\n",p,l,r);
     if (l <= node[p].l && node[p].r <= r)
        node[p].cover++;
     else {
           int mid = (node[p].l + node[p].r) >> 1;
           if (mid > l)
              Insert(node[p].lnd,l,r);
           if (mid < r)
              Insert(node[p].rnd,l,r);
          }
     upData(p);
}

void Delete(int p,int l,int r)
{
     if (l <= node[p].l && node[p].r <= r)
        node[p].cover--;
     else {
           int mid = (node[p].l + node[p].r) >> 1;
           if (mid > l)
              Delete(node[p].lnd,l,r);
           if (mid < r)
              Delete(node[p].rnd,l,r);
          }
     upData(p);
}

int Bi_Search(double key)
{
    int l = 1,r = cnty + 1,mid;
    while (l < r)
    {
          mid = (l + r) >> 1;
          if (fabs(indx[mid] - key) < eps)
             return mid;
          else if (indx[mid] + eps < key)
                  l = mid + 1;
               else r = mid;
    }
}

void Init_Index()
{
     sort(indx+1,indx+1+cnty);
     int m = 1;
     for (int i = 2; i <= cnty; i++)
         if (fabs(indx[i] - indx[i-1]) > eps)
         {
          //  printf("%lf \n",indx[i]);
            m ++;
            indx[m] = indx[i];
         }
     cnty = m;
}

bool cmp(const Line &a,const Line &b)
{
     return a.x < b.x;
}

int main()
{
    int n,i,j,k,left,right,cas = 1;
    double x1,x2,y1,y2,prelen,ans,ny1,ny2;
    while (scanf("%d",&n) && n)
    {
          for (i = 1; i <= n + n; i+=2)
          {
              scanf("%lf %lf %lf %lf",&x1,&y1,&x2,&y2);
              ny1 = min(y1,y2);
              ny2 = max(y2,y1);
              line[i].x = x1; line[i].y1 = ny1; line[i].y2 = ny2;
              line[i].f = true;
              line[i+1].x = x2; line[i+1].y1 = ny1; line[i+1].y2 = ny2;
              line[i+1].f = false;
              indx[i] = y1; indx[i+1] = y2;
          }
          sort(line+1,line+1+n+n,cmp);
          cnty = n + n;
          Init_Index();
         // printf("cnty = %d\n",cnty);
          Creat(root,1,cnty);
          left = Bi_Search(line[1].y1);
          right = Bi_Search(line[1].y2);
          Insert(root,left,right);
          prelen = node[root].len;
          ans = 0;
          for (i = 2; i <= n+n ;i++)
          {
              left = Bi_Search(line[i].y1);
              right = Bi_Search(line[i].y2);
              if (line[i].f)
                  Insert(root,left,right);
              else Delete(root,left,right); 
              ans += prelen*(line[i].x - line[i-1].x);
              prelen = node[root].len;
          //    printf("i = %d,len = %lf\n",i,prelen);
          }
          printf("Test case #%d\n",cas++);
          printf("Total explored area: %.2lf\n\n",ans);
         
    }
    return 0;
}

acronix 2010-10-29 14:17 发表评论

poj2352stars 点线段树和树状数组

acronix — Fri, 29 Oct 2010 06:12:00 GMT

题意：给星星的坐标，定义每个星星左下角（包括正左边和正上方）的星星数是它的level，统计各个level的星星数。

分析：乍看是个二维的统计，因为数据给出的是 y坐标升序，y相等 x坐标升序，所以可以一次读入数据，只要统计 x左边的星星数就行了，

这道题很好的启示就是二维降一维的方法————按某种规则排序。

下面给出了线段树和树状数组的写法。

点线段树cpp代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;

const int root = 0;
struct Node{
       int l,r,cnt;
       int lnd,rnd;
}node[60005];
int cnt,cntx;
int indx[15010];
int x[15010],y[15010];


void Creat(int p,int l,int r)
{
     node[p].l = l; node[p].r = r;
     node[p].cnt = 0;
     if (l < r)
     {
           int mid = (l + r) >> 1;
           node[p].lnd = ++cnt;
           Creat(cnt,l,mid);
           node[p].rnd = ++cnt;
           Creat(cnt,mid+1,r);
     }
     else {node[p].lnd = node[p].rnd = -1;}
}

void upData(int p)
{
     if (node[p].l < node[p].r)
        node[p].cnt = node[node[p].lnd].cnt + node[node[p].rnd].cnt;
}

void Insert(int p,int id)
{
     if (id == node[p].l && id == node[p].r)
         node[p].cnt++;
     else {
            int mid = (node[p].l + node[p].r) >> 1;
            if (mid < id)
               Insert(node[p].rnd,id);
            else Insert(node[p].lnd,id);
          }
     upData(p);
}

int  query(int p,int l,int r)
{
     int ans = 0;
     if (l <= node[p].l && node[p].r <= r)
        ans = node[p].cnt;
     else{
          int mid = (node[p].l + node[p].r) >> 1;
          if (mid >= l)
             ans += query(node[p].lnd,l,r);
          if (mid < r)
             ans += query(node[p].rnd,l,r);
         }
     return ans;
}
int Bi_Search(int key)
{
    int l = 1,r = cntx+1,mid;
    while (l < r)
    {
          mid = (l + r) >> 1;
          if (indx[mid] == key)
             return mid;
          else if (indx[mid] < key)
                  l = mid + 1;
              else r = mid;
    }
}

void Init_Index()
{
     sort(indx+1,indx+1+cntx);
   //  for (int i = 1; i <= cntx; i++)
  //       printf("%d,",indx[i]);
     int m = 1; 
     for (int i = 2; i <= cntx; i++)
     {
         
         if (indx[i] != indx[i-1])
         {
            m++;
            indx[m] = indx[i];
         }
     }
         
     cntx = m;
}

int main()
{
    int n,i,j,k,id;
    int count[15010];
    while (scanf("%d",&n) != EOF)
    {
          for (i = 1; i <= n; i++)
          {
              count[i] = 0;
              scanf("%d %d",&x[i],&y[i]);
              indx[i] = x[i];
          }
         // for (i = 1; i <= n ;i++)
        //      printf("%d ",indx[i]);
        //  printf("\n");
          cntx = n; 
          Init_Index();
       /*   for (i = 1; i <= cntx; i++)
              printf("%d ",indx[i]);
           printf("cntx = %d\n",cntx);*/
          cnt = 0;
          Creat(root,1,cntx);
          for (i = 1; i <= n; i++)
          {
              id = Bi_Search(x[i]);
            //  printf("id = %d\n",id);
              k = query(root,1,id);
            //  printf("i = %d,k = %d\n",i,k);
              count[k] ++;
              Insert(root,id);
          }
          for (i = 0; i < n; i++)
              printf("%d\n",count[i]);
          
    }
    return 0;
}

树状数组的cpp代码：

#include<stdio.h>
int a[32002];
int level[15000];
int N;
int lowbit(int n){
    return n&(-n);
}
int Sum(int n)
{
    int result = 0;
    while(n!=0){
        result+=a[n];
        n-=lowbit(n);
    }
    return result;
}
void Update(int n)
{
    while(n<=32001){
        a[n]++;
        n+=lowbit(n);
    }
}
void init()
{
    int i;
    for(i=0;i<=N;i++)
        level[i]=a[i]=0;
}
int main()
{
    int x,y,i;
    scanf("%d",&N);
    i=N;
    init();
    while(i--){
        scanf("%d %d",&x,&y);
        level[Sum(x+1)]++;
        Update(x+1);
        
    }

    for(i=0;i<N;i++)
        printf("%d\n",level[i]);
}

acronix 2010-10-29 14:12 发表评论

poj3277City Horizon线段树求矩阵面积并

acronix — Fri, 29 Oct 2010 06:01:00 GMT

题意就不多说了。

分析：就是把poj1177简单改动就行了。

总结：出错时输出看看prelen对不对就行了。

#include <cstdio>
#include <stdlib.h>
#include <algorithm>
using namespace std;

const int root = 0;

struct Node{
       int l,r,cover;
       int cnt,len;
       int lf,rf;
       int lnd,rnd;
}node[200010];
int cnt,cnty;
int indx[80010];

struct Line{
       int x,y1,y2;
       bool f;
} line[80010];

void Creat(int p ,int l,int r)
{
     node[p].l = l; node[p].r = r;
     node[p].len = node[p].cnt = node[p].cover = 0;
     node[p].lf = node[p].rf = 0;
     if(r - l > 1)
     {
          int mid = (l + r) >> 1;
          node[p].lnd = ++cnt;
          Creat(cnt,l,mid);
          node[p].rnd = ++cnt;
          Creat(cnt,mid,r);
     }
     else {node[p].lnd = -1; node[p].rnd = -1;}
}

void upData(int p)
{
     if (node[p].cover > 0)
     {
         node[p].len = indx[node[p].r] - indx[node[p].l];
         node[p].cnt = 1;
         node[p].lf = node[p].rf = 1;
     }
     else if (node[p].l == node[p].r -1)
          {
             node[p].cover = 0;
             node[p].len = 0;
             node[p].lf = node[p].rf = node[p].cnt = 0;
          }
          else {
                int left = node[p].lnd;
                int right = node[p].rnd;
                node[p].len = node[left].len + node[right].len;
                node[p].lf = node[left].lf;
                node[p].rf = node[right].rf;
                node[p].cnt = node[left].cnt + node[right].cnt - node[left].rf*node[right].lf;
               }
}

void Insert(int p,int l,int r)
{
     if(l <= node[p].l && node[p].r <= r)
          node[p].cover ++;
     else {
            int mid = (node[p].l + node[p].r) >> 1;
            if(mid > l)
                   Insert(node[p].lnd,l,r);
            if (mid < r)
               Insert(node[p].rnd,l,r);
          }
     upData(p);
}

void Delete(int p,int l,int r)
{
     if(l <= node[p].l && node[p].r <= r)
          node[p].cover--;
     else {
             int mid = (node[p].l + node[p].r) >> 1;
             if(mid > l)
                    Delete(node[p].lnd,l,r);
             if (mid < r)
                Delete(node[p].rnd,l,r);
          }
     upData(p);
}

bool cmp(const Line &a,const Line &b)
{
    return a.x < b.x;
}

int Bi_Search(int key)//二分查找 
{
    int l = 1,r = cnty+1,mid;
    while (l < r)
    {
          mid = (l + r) >> 1;
          if(indx[mid] == key)
              return mid;
          else if(indx[mid] < key)
                  l  = mid + 1;
               else r = mid; 
    }
}

void Init_Index()//离散化（排序= 去重 
{
    sort(indx+1,indx+1+cnty);
    int m = 1;
    for (int i = 2; i <= cnty; i++)
        if(indx[i] != indx[i-1])
        {
           m++;
           indx[m] = indx[i];
        }
    cnty = m;
}

int main()
{
    int n,i,j;
    long long ans;
    int x,y,h,prelen,left,right;
    while (scanf("%d",&n) != EOF)
    {
          cnty = 1;
          indx[cnty] = 0;
          for (i = 1; i <= n+n; i+=2)
          {
              scanf("%d %d %d",&x,&y,&h);
              line[i].x = x; line[i].y1 = 0; line[i].y2 = h; 
              line[i].f = true;
              line[i+1].x = y; line[i+1].y1= 0; line[i+1].y2 = h; 
              line[i+1].f = false;
              indx[++cnty] = h;
          }
          sort(line+1,line+1+n+n,cmp);
          Init_Index();
          cnt = 0;
          Creat(root,1,cnty);
          left = 1;
          right = Bi_Search(line[1].y2);
          Insert(root,left,right);
          prelen = node[root].len;
          ans = 0;
          //printf("1.len = %d\n",prelen);
          for (i = 2; i <= n+n; i++)
          {
              left  = 1;
              right = Bi_Search(line[i].y2);
              
              if (line[i].f)
                 Insert(root,left,right);
              else Delete(root,left,right);
              
              //注意 long long 
              ans += (long long)prelen*((long long)line[i].x - (long long)line[i-1].x);
              prelen = node[root].len; 
              /****************检查出错很好的手段************************/
              //printf("i = %d.len = %d\n",i,prelen); 
          }
          printf("%I64d\n",ans);
    }
    return 0;
}

acronix 2010-10-29 14:01 发表评论

poj1177Pictue线段树 + 离散化 + 矩阵周长并

acronix — Fri, 29 Oct 2010 05:57:00 GMT

题意：就是求重叠的矩阵轮廓的周长。
总结：理解线段树最好的方法就是利用样例，或者自己利用模型模拟一遍，然后就是边模拟边想代码的实现。
我的写法是比较正规的二叉树的形式，各个节点描述信息如下。
这个程序经典在于涵盖了线段树的基本操作和节点记录的数据，至于求矩阵面积交，只是缺少了扫描线区间个数的记录，这也是求矩阵周长并的关键。
具体cpp代码如下：

//poj1177Pucture线段树 
#include <cstdio>
#include <algorithm>
#include <stdlib.h>
using namespace std;
const int root = 0;

struct Node{
       int l,r;
       int cover,len,lines;//vover记录覆盖次数，len长度，lines记录并区间数 
       int lf,rf;//记录左右节点是否被覆盖 
       int lnd,rnd;//记录左右节点 
}node[20005];
int cnt,cnty;
int indexy[10010];//离散纵坐标y的数组 

struct Cord{
       int x,y1,y2;
       bool f;
}cord[10005];//竖线 
int n;

void Creat(int p,int l,int r)
{
     node[p].l = l;   node[p].r = r;
     node[p].lf = node[p].rf = 0;
     node[p].len = node[p].lines = 0;
     if (r - l > 1)
     {
           int mid = (r+l) >> 1;
           node[p].lnd = ++cnt;
           Creat(cnt,l,mid); //递归创建左子树 
           node[p].rnd = ++cnt;
           Creat(cnt,mid,r);//递归创建右子树 
     }
     else {
            node[p].lnd = node[p].rnd = -1;
          }
}

void upData(int p)  //每次插入或删除后的更新操作
{
     if (node[p].cover > 0)  //整条线段被覆盖
     {
        node[p].len = indexy[node[p].r] - indexy[node[p].l];
        node[p].lines = 1;
        node[p].lf = node[p].rf = 1;
     }
     else if (node[p].l == node[p].r - 1) //未被覆盖的元线段 
          {
                node[p].lf = node[p].rf = 0;
                node[p].len = node[p].lines = 0;
          }
          else {                                 //未被覆盖的非元线段 
                 int left = node[p].lnd;
                 int right = node[p].rnd;
                 node[p].lf = node[left].lf;
                 node[p].rf = node[right].rf;
                 node[p].len = node[left].len + node[right].len;
                 node[p].lines = node[left].lines + node[right].lines - node[left].rf*node[right].lf;
               }
}

void Insert(int p,int l,int r) //插入线段 
{
     if (l <= node[p].l && node[p].r <= r)
        node[p].cover ++;
     else {
             int mid = (node[p].l+node[p].r) >> 1;
              
             if (mid > l)
                Insert(node[p].lnd,l,r);
             if (mid < r)
                Insert(node[p].rnd,l,r);     
          }
          
     upData(p);
}

void Delete(int p,int l,int r) //删除线段 
{
     if (l <= node[p].l && node[p].r <= r)
     {
         node[p].cover --; 
     }   
     else {
             int mid = (node[p].l+node[p].r) >> 1;
             if (mid > l)
                Delete(node[p].lnd,l,r);
             if (mid < r)
                Delete(node[p].rnd,l,r);     
          }
     upData(p);
}

bool cmp(const Cord &a,const Cord &b)
{
     return a.x < b.x;
}

void init_index() //对纵坐标离散去重 
{
     sort(indexy+1,indexy+1+cnty);
     int m = 1;
     for (int i = 2; i <= cnty; i++)
     {
         if (indexy[i] != indexy[i-1])
         {
            m++;
            indexy[m] = indexy[i];
         }
     }
     cnty = m;
}

int Bi_search(int key) //二分查找 y 对应的离散坐标 
{
    int l = 1,r = cnty + 1,mid;
    while (l < r)
    {
          mid = (l + r) >> 1;
          if (indexy[mid] == key)
             return mid;
          if (indexy[mid] < key)
             l = mid + 1;
          else r = mid;
    }
}

int main()
{
    int i,j,left,right,prelen,prelines;
    int x1,x2,y1,y2;
    int ans;
    while (scanf("%d",&n) != EOF)
    {
          for (i = 1;i <= n + n;  i+=2)
          {
              scanf("%d %d %d %d",&x1,&y1,&x2,&y2);
              cord[i].x = x1; cord[i].y1 = y1; cord[i].y2 = y2; 
              cord[i].f = true;
              cord[i+1].x = x2; cord[i+1].y1 = y1; cord[i+1].y2 = y2;
              cord[i+1].f = false;
              indexy[i] = y1;
              indexy[i+1] = y2;
          }
          
          sort(cord+1,cord+1+n+n,cmp);
          cnty = n+n;
          init_index();
          cnt = 0;
          Creat(root,1,cnty);
          
          left = Bi_search(cord[1].y1);
          right = Bi_search(cord[1].y2);
              
          Insert(root,left,right);
          prelen = node[root].len; 
          prelines = node[root].lines;
          ans = prelen;
          
          for (i = 2; i <= n+n; i++)
          {
              left = Bi_search(cord[i].y1);
              right = Bi_search(cord[i].y2);
               
              if (cord[i].f)
                   Insert(root,left,right);
              else {
                    Delete(root,left,right);
                   }
              ans += abs(prelen - node[root].len); //纵向周长增长量为前后两次被覆盖线段长度的改变量 
              ans += prelines*(cord[i].x - cord[i-1].x)*2; //横向周长的增长量为上一次区间个数乘2在乘横向长度
              prelen = node[root].len;
              prelines = node[root].lines;
          }
          printf("%d\n",ans);
    }
    return 0;
}

acronix 2010-10-29 13:57 发表评论

codeforces36#

acronix — Tue, 19 Oct 2010 15:21:00 GMT

problem A
      水题不解释.
problem B
     题意还是见：http://codeforces.com/contest/36/problem/B
    做法是不断递归白色的区域，直到此区域的len == n。
cpp代码：

#include <cstdio>
#include <stdlib.h>

char a[5][5],mp[300][300];
int n,k;

void Orig(int x,int y)
{
   //  printf("Orig: x = %d,y = %d\n",x,y);
     for (int i = 0; i < n; i++)
     {
         for (int j = 0; j <  n; j++)
         {
            mp[x+i][y+j] = a[i][j]; 
           // printf("%d,%d--%c",x+i,y+j,a[i][j]);
         } 
        // printf("\n");
     }
         
}

void Black(int len,int x,int y)
{
    // printf("Black:len = %d,x = %d,y = %d\n",len,x,y);
     for (int i = x; i < len + x; i++)
         for (int j = y; j < len + y; j++)
             mp[i][j] = '*';
}

void paint(int len,int i,int j)
{
     if (len == n)
        Orig(i,j);
     else {
             int cnt = len / n;
             for (int x = 0; x < n; x++)
                 for (int y = 0; y < n; y++)
                     if (a[x][y] == '*')
                        Black(cnt,i+cnt*x,j+cnt*y);
                     else paint(cnt,i+cnt*x,j+cnt*y);
          }
}

int myPow(int n,int k)
{
    int m = 1;
    while (k > 0)
    {
          m *= n;
          k--;
    }      
    return m;
}

int main()
{
    int i,j;
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    while (scanf("%d %d",&n,&k) != EOF)
    {
          int len = myPow(n,k);
          
          for (i = 0; i < n; i++)
              scanf("%s",a[i]);
          paint(myPow(n,k),1,1);
          for (i = 1; i <= len; i++)
          {
              for (j = 1; j <= len; j++)
                  printf("%c",mp[i][j]);
              printf("\n");
          }
         // /*********/printf("----------------\n\n");
    }
    
    return 0;
}

problem C
      题见：http://codeforces.com/contest/36/problem/C
     我觉得这是一个比较好的题。首先，需要必要的数学知识就是相似三角形各边的比例关系。然后，就是判断每来一个碗时它会在哪个碗之上？比赛时我没时间想明白后来看了xpree的代码后猛然发觉，其实可以枚举前面放过的碗中每个碗可以使来的碗 i 有一个上升的高度up[i]，求up[i] + h[j]最大值即可。枚举O（n*n）的。这给我的收获就是：在不确定的情况下，枚举是最好的方法，类似动态规划很多时候都是用这个思想，然后得到下一个最优子结构。
     接下来的问题就是求两碗之间的碗底高度差了，这里 i 代表放过的碗，j 代表要放的碗，情况就是三类：1、r[j] >= R[i] 就是j 在 i 的顶部：2、j 能完全i内，高度差为0：2、j 卡在 i 中间或 i 内部。具体的情况自己画画图就明白了；
CPP代码：

#include <cstdio>
#include <cstdio>
#include <algorithm>
using namespace std;

const double eps = 1e-8;
const int MAX = 3005;
double  r[3005],R[3005],h[3005],up[3005],k[3005];

double cmp(int i,int j)
{
       if (R[i] <= r[j])// j 在 i 顶部 
          return h[i];
          
       if (r[i] > r[j]) // j 完全在 i 内部，两者碗底的高度差为 0 
       {
           if (k[j] < k[i] )
              return 0;
           if (h[i] <= h[j] && (h[i]*(R[j]-r[j])/h[j] + r[j]) <= R[i])
              return 0;
           if (h[i] >= h[j] && (h[j]*(R[i]-r[i])/h[i] + r[i]) >= R[j])
              return 0;
       }
       if (k[j] > k[i]) // j 卡在 i 中 
          {
                 if (R[j] >= R[i])
                    return h[i] - (R[i]-r[j])*h[j]/(R[j] - r[j]);
                 else return (R[j]-r[i])*h[i]/(R[i]-r[i]) - h[j];
            }
       else return h[i]*(r[j]-r[i])/(R[i]-r[i]);
}

int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    
    int n,i,j;
    double ans,d;
    while (scanf("%d",&n) != EOF)
    {
          for (i = 1; i <= n; i++)
          {
              up[i] = 0;
              scanf("%lf %lf %lf",&h[i],&r[i],&R[i]);
              k[i] = (R[i] - r[i]) / h[i];
          }
          ans = 0;
          for (i = 1; i <= n; i++)
          {
              //枚举 i 之前的碗，看 i 会在 那个上面 
              for (j = 1; j < i ; j++)
              {
                  d = cmp(j,i);
               //   printf("i = %d,j = %d,d = %lf\n",i,j,d);
                  up[i] = max(up[i],up[j]+d);     
              }//printf("ans = %lf\n",ans);
              ans = max(ans,up[i]+h[i]);
              
          }
          printf("%.8lf\n",ans);
              
    }
    return 0;
}

acronix 2010-10-19 23:21 发表评论

poj1177Picture(线段树+离散化)

acronix — Fri, 15 Oct 2010 17:24:00 GMT

题意就不说了，主要是看陈宏的论文和Magicfly的模板终于初步了解了线段树，真是个强大的东西啊。

说点自己写的时候遇到的问题吧：
注意：左右节点的被覆盖的标记和并区间的计算。
教训：Ctrl+C，Ctrl+V害惨我了，把Insert的代码直接贴到Delete那去，后来看了好久才会过神来，代码能力不够啊。
上代码：

//poj1177Pucture线段树 
#include <cstdio>
#include <algorithm>
#include <stdlib.h>
using namespace std;
const int root = 0;

struct Node{
       int l,r;
       int cover,len,lines;//vover记录覆盖次数，len长度，lines记录并区间数 
       int lf,rf;//记录左右节点是否被覆盖 
       int lnd,rnd;//记录左右节点 
}node[40005];
int cnt,cnty;
int indexy[10010];//离散纵坐标y的数组 

struct Cord{
       int x,y1,y2;
       bool f;
}cord[10005];//竖线 
int n;

void Creat(int p,int l,int r)
{
     node[p].l = l;   node[p].r = r;
     node[p].lf = node[p].rf = 0;
     node[p].len = node[p].lines = 0;
     if (r - l > 1)
     {
           int mid = (r+l) >> 1;
           node[p].lnd = ++cnt;
           Creat(cnt,l,mid); //递归创建左子树 
           node[p].rnd = ++cnt;
           Creat(cnt,mid,r);//递归创建右子树 
     }
     else {
            node[p].lnd = node[p].rnd = -1;
          }
}

void upData(int p)  //每次插入或删除后的更新操作
{
     if (node[p].cover > 0)  //整条线段被覆盖
     {
        node[p].len = indexy[node[p].r] - indexy[node[p].l];
        node[p].lines = 1;
        node[p].lf = node[p].rf = 1;
     }
     else if (node[p].l == node[p].r - 1) //未被覆盖的元线段 
          {
                node[p].lf = node[p].rf = 0;
                node[p].len = node[p].lines = 0;
          }
          else {                                 //未被覆盖的非元线段 
                 int left = node[p].lnd;
                 int right = node[p].rnd;
                 node[p].lf = node[left].lf;
                 node[p].rf = node[right].rf;
                 node[p].len = node[left].len + node[right].len;
                 node[p].lines = node[left].lines + node[right].lines - node[left].rf*node[right].lf;
               }
}

void Insert(int p,int l,int r) //插入线段 
{
     if (l <= node[p].l && node[p].r <= r)
        node[p].cover ++;
     else {
             int mid = (node[p].l+node[p].r) >> 1;
              
             if (mid > l)
                Insert(node[p].lnd,l,r);
             if (mid < r)
                Insert(node[p].rnd,l,r);     
          }
          
     upData(p);
}

void Delete(int p,int l,int r) //删除线段 
{
     if (l <= node[p].l && node[p].r <= r)
     {
         node[p].cover --; 
     }   
     else {
             int mid = (node[p].l+node[p].r) >> 1;
             if (mid > l)
                Delete(node[p].lnd,l,r);
             if (mid < r)
                Delete(node[p].rnd,l,r);     
          }
     upData(p);
}

bool cmp(const Cord &a,const Cord &b)
{
     return a.x < b.x;
}

void init_index() //对纵坐标离散去重 
{
     sort(indexy+1,indexy+1+cnty);
     int m = 1;
     for (int i = 2; i <= cnty; i++)
     {
         if (indexy[i] != indexy[i-1])
         {
            m++;
            indexy[m] = indexy[i];
         }
     }
     cnty = m;
}

int Bi_search(int key) //二分查找 y 对应的离散坐标 
{
    int l = 1,r = cnty + 1,mid;
    while (l < r)
    {
          mid = (l + r) >> 1;
          if (indexy[mid] == key)
             return mid;
          if (indexy[mid] < key)
             l = mid + 1;
          else r = mid;
    }
}

int main()
{
    int i,j,left,right,prelen,prelines;
    int x1,x2,y1,y2;
    int ans;
    while (scanf("%d",&n) != EOF)
    {
          for (i = 1;i <= n + n;  i+=2)
          {
              scanf("%d %d %d %d",&x1,&y1,&x2,&y2);
              cord[i].x = x1; cord[i].y1 = y1; cord[i].y2 = y2; 
              cord[i].f = true;
              cord[i+1].x = x2; cord[i+1].y1 = y1; cord[i+1].y2 = y2;
              cord[i+1].f = false;
              indexy[i] = y1;
              indexy[i+1] = y2;
          }
          
          sort(cord+1,cord+1+n+n,cmp);
          cnty = n+n;
          init_index();
          cnt = 0;
          Creat(root,1,cnty);
          
          left = Bi_search(cord[1].y1);
          right = Bi_search(cord[1].y2);
              
          Insert(root,left,right);
          prelen = node[root].len; 
          prelines = node[root].lines;
          ans = prelen;
          
          for (i = 2; i <= n+n; i++)
          {
              left = Bi_search(cord[i].y1);
              right = Bi_search(cord[i].y2);
               
              if (cord[i].f)
                   Insert(root,left,right);
              else {
                    Delete(root,left,right);
                   }
              ans += abs(prelen - node[root].len); //纵向周长增长量为前后两次被覆盖线段长度的改变量 
              ans += prelines*(cord[i].x - cord[i-1].x)*2; //横向周长的增长量为上一次区间个数乘2在乘横向长度
              prelen = node[root].len;
              prelines = node[root].lines;
          }
          printf("%d\n",ans);
    }
    return 0;
}

acronix 2010-10-16 01:24 发表评论

hdu3359 kind of blur高斯消元，线性代数知识的第一次运用

acronix — Sun, 03 Oct 2010 15:19:00 GMT

其他的都不多说了，列出A*X=B方程，找出系数A矩阵和解B，

教训：查了个把小时的错，计算[i,j]为宽w，高h 中第几个数时弄错了，应该每行 w 个。

收获：rt，还有知道了swap（，）这个交换两变量数据的函数

#include <cstdio>
#include <iostream>
#include <stdlib.h>
#include <cmath>
using namespace std;

const int M = 105;
double a[M][M],b[M];
double map[15][15];

int w,h,d,len;

/***********************************************************/
/*******len为解的个数，a[][]*X[] = b[],解在b【】中*****************************************************/
void Guass()
{
    int id,i,j,k;
    double max,temp;
    k = 1;
    while (k <= len)
    {
        max = fabs(a[k][k]);
        id = k;
        //change the max!!!
        for (i = k+1; i <= len; i++)
        {
            if (max < fabs(a[i][k]))
            {
                max = fabs(a[i][k]);
                id = i;
            }
        }
        if (k != id)
        {
           //新发现，有swap交换函数能用
            swap(b[id],b[k]);
            for (i = 1; i <= len; i++)
                swap(a[id][i],a[k][i]);
        }
        //to gauss
        b[k] /= a[k][k];
        temp = a[k][k];
        for (i = k; i <= len; i++)
        {
            a[k][i] /= temp;
        }
        for (i = 1;  i <= len; i++)
            if (i != k)
            {
                temp = a[i][k];
                b[i] -= b[k]*temp;
                for (j = k; j <= len;  j++)
                    a[i][j] -= a[k][j]*temp;
            }
       k ++;
    }
}

/*************************************************************************/
int main()
{
//   freopen("blur.in","r",stdin);
    int i,j,p,q,id,count,sum,cas = 1,cnt;

    while (scanf("%d %d %d",&w,&h,&d))
    {
        if (w == 0 && h == 0 && d == 0)
            break;
        else if (cas != 1)
                printf("\n");
        cas ++;

        len = w * h;
        for (i = 1; i <= h; i++)
            for (j = 1; j <= w; j ++)
                scanf("%lf",&map[i][j]);

        for (i = 1; i <= len; i++)
            for (j = 1; j <= len; j++)
                a[i][j] = 0.0;

        for (i = 1; i <= h; i++)
            for (j = 1;  j <= w; j++)
            {
                cnt = (i-1) * w + j;
                b[cnt] = map[i][j];
                count = 0;
                for (p = i - d; p <= i + d; p ++)
                    for (q = j - d; q <= j + d ; q ++)
                {

                    if (abs(p-i) + abs(q-j) <= d && p >= 1 && p <= h && q >= 1 && q <= w)
                    {
                        id = (p-1)*w + q;
                        a[cnt][id] = 1;
                        count ++;
                    }
                }
                b[cnt] *= count;
            }
        Guass();
        for (i = 1; i <= len; i++)
        {
            printf("%8.2lf",b[i]);
            if (i % w == 0)
                printf("\n");
        }

    }
//   while (1) ;
    return 0;
}

acronix 2010-10-03 23:19 发表评论

杭电OJ题目分类

acronix — Fri, 24 Sep 2010 14:08:00 GMT

分类一：

基础题：1000、1001、1004、1005、1008、1012、1013、1014、1017、1019、1021、1028、1029、1032、1037、1040、1048、1056、1058、1061、1070、1076、1089、1090、1091、1092、1093、1094、1095、1096、1097、1098、1106、1108、1157、1163、1164、1170、1194、1196、1197、1201、1202、1205、1219、1234、1235、1236、1248、1266、1279、1282、1283、1302、1303、1323、1326、1330、1334、1335、1339、1390、1391、1393、1395、1397、1405、1406、1407、1408、1412、1418、1420、1465、1491、1555、1562、1563、1570、1587、1673、1678、1708、1718、1720、1785、1799、1859、1862、1877、1898、1976、1977、1985、1994、2000、2001、2002、2003、2004、2005、2006、2007、2008、2009、2010、2011、2012、2013、2014、2015、2016、2017、2018、2019、2020、2021、2022、2023、2024、2025、2026、2027、2028、2029、2030、2031、2032、2033、2034、2035、2039、2040、2042、2043、2048、2049、2051、2053、2055、2056、2057、2060、2061、2071、2073、2075、2076、2078、2081、2083、2088、2090、2092、2093、2095、2096、2097、2098、2099、2101、2103、2106、2107、2109、2113、2114、2115、2123、2131、2132、2133、2135、2136、2137、2138、2139、2143、2148、2153、2156、2161、2162、2164、2178、2186、2192、2200、2201、2212、2304、2309、2317、2401、2500、2502、2503、2504、2519、2520、2521、2523、2524、2535、2537、2539、2547、2548、2549、2550、2551、2552、2555、2560、2561、2562、2566、2567、2568、2700、2710、

DP：1003、1024、1029、1069、1074、1087、1114、1159、1160、1171、1176、1203、1231、1257、1260、1284、1421、1789、1978、2059、2084、2159、2191、2544、2571、2602、2709、

搜索：1010、1015、1016、1026、1072、1075、1175、1180、1181、1238、1239、1240、1241、1242、1253、1254、1312、1372、1548、1597、1671、1677、1728、1800、1983、2102、2141、2553、2563、2605、2612、2614、1616、2717

贪心：1009、1045、1049、1050、1051、1052、1257、1800、2037、2111、2124、2187、2391、2570

数学题：1018、1065、1071、1115、1141、1162、1212、1220、1492、1593、1701、1722、1798、1840、1999、2036、2080、2086、2089、2105、2108、2134、2303、2393、2438、2529、2547、2548、2552、2554、2601、2603、2701、

递推：1133、1143、1207、1249、1267、1284、1290、1297、1396、1992、1995、1996、2013、2014、2044、2045、2046、2047、2050、2064、2065、2067、2068、2070、2077、2085、2151、2154、2160、2190、2501、2512、2563、2569、2709、2716、

字符串：1020、1039、1043、1062、1073、1075、1088、1113、1161、1200、1251、1256、1288、1321、1328、1379、1804、1860、1982、1984、2017、2024、2025、2026、2027、2043、2052、2054、2072、2074、2087、2131、2137、2140、2163、2203、2206、2352、2500、2549、2564、2565、2567、2572、2609、2607、2707、2708、2719、2721、2723、

大数：1002、1042、1133、1250、1297、1715、1753、1865、2100、

胡搞：1022、1027、1030、1035、1128、1165、1209、1210、1215、1222、1228、1229、1230、1237、1259、1276、1286、1337、1342、1361、1370、1506、1577、1597、1702、1716、1727、1868、1870、1896、1981、1986、1987、1988、1997、1998、1999、2058、2062、2089、2090、2094、2104、2116、2117、2135、2175、2183、2184、2197、2303、2368、2370、2374、2511、2522、2527、2600、2615、2703、2711、2714、2715、2725、

博弈：1077、1404、1517、1524、1525、1527、1536、1564、1729、1730、1846、1847、1848、1849、1850、2147、2149、2176、2177、2188

母函数：1085、1171、1398、2079、2082、2110、2152、2189、2566、

hash：1264、1280、1425、1496、1800、2522、2600、

分类二：

附：2000-2099全是水题。

1001 这个就不用说了吧

1002 简单的大数

1003 DP经典问题，最大连续子段和

1004 简单题

1005 找规律（循环点）

1006 感觉有点BT的题，我到现在还没过

1007 经典问题，最近点对问题，用分治

1008 简单题

1009 贪心

1010 搜索题，剪枝很关键

1011

1012 简单题

1013 简单题（有个小陷阱）

1014 简单题

1015 可以看作搜索题吧

1016 经典的搜索

1017 简单数学题

1018 简单数学题

1019 简单数学题

1020 简单的字符串处理

1021 找规律的数学题

1022 数据结构的题（栈的应用）

1023 特殊的数（Catalan Number）

1024 经典DP，最大M子段和

1025 经典DP，最长递增子序列（要用NLogN的方法过）

1026 搜索

1027 数学题（或用STL）

1028 经典问题，整数拆分，用母函数做

1029 简单题（一般方法容易超时）

1030 简单题，可用模拟过

1031 简单题

1032 简单题

1033 模拟题

1034 Candy Sharing Game

1035 模拟题

1036 简单题

1037 简单题，不是一般的简单

1038 简单题

1039 字符串处理

1040 简单题，排序

1041 简单题，用大数

1042 大数

1043 经典搜索题，八数码问题

1044 稍微有点麻烦的搜索题

1045 搜索题，可用匹配做

1046 简单题

1047 简单的大数

1048 简单字符串处理

1049 简单题

1050 贪心

1051 经典贪心，也可以用DP

1052 贪心

1053 贪心，关于Huffman编码

1054 二分匹配

1055 二分匹配

1056 简单题

1057 模拟题

1058 经典问题，丑数，DP

1059 经典问题，可以用母函数或DP（不针对题目优化都会超时）

1060 数学题

1061 数学题

1062 简单字符串处理

1063 模拟大数

1064 简单题

1065 简单题

1066 数学题，找规律

1067

1068 经典二分匹配

1069 经典DP

1070 简单题

1071 简单数学题

1072 搜索

1073 字符串处理

1074 DP

1075 字典树

1076 简单题

1077

1078 DP

1079 博弈（DP）

1080 DP

1081 经典DP

1082 简单题

1083 二分匹配

1084 简单题

1085 母函数

1086 简单几何题

1087 简单DP

1088 字符串处理

1089~1096 （练习输入输出的8个题目）

1097 简单数学题

1098 数学题，注意找规律

1099 数学题

模拟题, 枚举

1002 1004 1013 1015 1017 1020 1022 1029 1031 1033 1034 1035 1036 1037 1039 1042 1047 1048 1049 1050 1057 1062 1063 1064 1070 1073 1075 1082 1083 1084 1088 1106 1107 1113 1117 1119 1128 1129 1144 1148 1157 1161 1170 1172 1177 1197 1200 1201 1202 1205 1209 1212(大数取模) 1216（链表）1218 1219 1225 1228 1229 1230 1234 1235 1236 1237 1239 1250

1256 1259 1262 1263 1265 1266 1276 1279 1282 1283 1287 1296 1302 1303 1304 1305 1306 1309 1311 1314

复杂模拟

搜索，递归求解

1010 1016 1026 1043(双广) 1044 (BFS+DFS) 1045 1067 1072 1104 1175 1180 1195 1208 1226 1238 1240 1241 1242 1258 1271 1312 1317

博奕

1079

动态规划

1003 1024 1025 1028 1051 1058 1059 1069 1074 1078 1080 1081 1085 1087 1114 1158 1159 1160 1171 1176 1181 1203 1224 1227 1231 1244 1248 1253 1254 1283 1300

数学，递推，规律

1005 1006 1012 1014 1018 1019 1021 1023 1027 1030 1032 1038 1041 1046 1059 1060 1061 1065 1066 1071(微积分) 1097 1098 1099 1100 1108 1110 1112 1124 1130 1131 1132 1134 1141 1143 1152 1155(物理题) 1163 1165 1178 1194 1196(lowbit) 1210 1214 1200 1221 1223 1249 1261 1267 1273 1290 1291 1292 1294 1297 1313 1316

数论

1164 1211 1215 1222 1286 1299

计算几何

1086 1115 1147

贪心

1009 1052 1055 1257

并查集

1198 1213 1232 1272

线段树,离散化

1199 1255

图论

最短路相关的问题 1142 1162 1217 1301

二分图问题 1054 1068 1150 1151 1281

其他

1053 (huffman) 1102(MST) 1116（欧拉回路） 1233(MST) 1269（强连通）

数据结构

1103（堆+模拟）1166（数状树组）1247 1251 1285（Topol） 1298

汉诺塔系列

1207

最近顶点对 1007

1500 DP

1501 DP

1502 DP or 记忆化

1503 DP

1504 模拟

1505 DP

1506 DP

1507 2分匹配

1508 记忆化容易点

1509 模拟

1510 DP

1511 搜索可以过

1512 左偏树

1513 DP

1514 DP

1515 DFS

1516 DP

1517 博奕

1518 搜索

1519 DP（不确定）

1520 树状DP

1521 数学题，母函数什么的。其实都可以过

1522 稳定婚姻

1523 DP

1524 博弈

1525 博弈

1526 Maxflow

1527 博弈

1528 2分匹配

1529 简单题

1530 最大团

1531 差分约束

1532 Maxflow 入门题

1533 KM Or 最小费用流

1534 差分约束

1535 差分约束

1536 博弈

1537 模拟加置换群的理论 CODE可以短些，其实没必要。。。

1538 很有意思的题目。据说是Microsoft亚洲总裁面试的题目

1539 搜索

1540 线段树

1541 树状数组

1542 离散，线段树

1543 线段树

1544 简单的

1545 DP http://acm.hdu.edu.cn/forum/htm_data/18/0608/2050.html

1546 搜索

1547 模拟

1548 模拟

1551 2分答案

1553

1554

1555 简单

1556 技巧。数学

1557 搜索

1558 并查 + 线段判交

1559 DP

1560 减支 + 搜索

1561 树状DP

1562 暴力 between 1000 and 9999

1563 简单

1564 博弈。

1565 状态DP

1566 数学

1567 模拟

1568 大数

1569 最小割

1570 数学

1571 最段路

1572 搜索

1573 数学

1574 DP

1575 2分

1576 数论

1577 模拟，处理精度

1579 记忆化

1580 DP

1582 搜索

1583 模拟

1584 搜索

1585

1586

1587 简单题目

1591 模拟

1592 简单

1593 数学

1594 数学

1595 图论

1596 图论

1597 图论

1598 图论

1599 图论

acronix 2010-09-24 22:08 发表评论

Java

acronix — Sun, 12 Sep 2010 08:52:00 GMT

http://apps.hi.baidu.com/share/detail/15834448

kmp http://tiandiwuyong1989.blog.163.com/blog/static/122572981200973175131929/

POJ http://hi.baidu.com/lewutian/blog/item/734c17181ab715bf4bedbc4b.html

acronix 2010-09-12 16:52 发表评论

hdu_3596 Lazy

acronix — Fri, 03 Sep 2010 13:53:00 GMT

题意：求算术表达式。

分析：表达式有中缀转化为后缀。设一个stack存后缀数据，一个rout栈存运算符。
方法：（1）从右向左依次取得数据ch。

            （2）如果ch是操作数，直接加进stack中。

（3）如果ch是运算符（含左右括号），则：
      a：如果ch = '('，放入堆栈rout中。
      b：如果ch = ')'，依次输出堆栈rout中的运算符，直到遇到'('为止。
      c：如果ch不是')'或者'('，那么就和堆栈rout顶点位置的运算符top做优先级比较。
          1：如果ch优先级比rtop高，那么将ch放入堆栈。
          2：如果ch优先级低于或者等于rtop，那么输出top到stack中（直到！top或者满足 1），然后将ch放入堆栈。

注：运算符的优先级：^ , *、/，%，+ -，注意本题多个乘方如2^(-1)^2^2是左结合，而我比赛的时用的是右结合，还有就是查了很多文档，很多都是右结合，所以暂时还没弄清。不过本题考查的重点还是栈的使用和中缀转后缀表达式或者用表达树。

cpp代码：

#include <cstdio>
#include <ctype.h>
#include <cmath>
#include <stdlib.h>
char rin[10100],rout[10100];
struct sta{
       double x;
       bool digit;
       char ch;
} stack[10100];
double tst[10100];
int top,ttop,rtop;

int priority(char ch)
{
    switch (ch)
    {
           case '+' : 
           case '-' : return 1;break;
           case '*' :
           case '/' : return 2;break;
           case '^' : return 3;break;
    }
}

int main()
{
 // freopen("Lazy.in","r",stdin);
 //   freopen("out.txt","w",stdout);
    int i;
    bool mark;
    while (scanf("%s",rin) != EOF)
    {
          mark = true;
          top = 0; i = 0; rtop = 0;
          while (rin[i])
          { 
                if (mark)
                {
                         mark = false;
                         while (rin[i] == '(')
                         {
                              i ++;  
                              rout[++rtop] = '(';    
                         }
                         if (rin[i] == '-' || rin[i] == '+')
                         {
                            stack[++top].x = 0;
                            stack[top].digit = true;
                         }      
                         else {
                               sscanf(&rin[i],"%lf",&stack[++top].x);
                               stack[top].digit = true;
                               while (!isdigit(rin[i]))
                                     i++;
                               while (isdigit(rin[i]) || rin[i] == '.')
                                     i++;
                              }
                }
                else {
                        mark = true;
                        if (rin[i] == ')')
                        {
                           while (rout[rtop] != '(')
                           {
                                 stack[++top].ch = rout[rtop--];
                                 stack[top].digit = false;
                           }
                           rtop--;
                           mark = false;         
                        }  
                        else {
                               if (!rtop || rout[rtop] == '(')
                                  rout[++rtop] = rin[i];
                               else {
                                      while ( rtop&& priority(rin[i]) < priority(rout[rtop]))
                                      {
                                        stack[++top].ch = rout[rtop--];
                                        stack[top].digit = false;
                                      }
                                      if (rtop && priority(rin[i]) == priority(rout[rtop]))
                                      {
                                          stack[++top].ch = rout[rtop];
                                          stack[top].digit = false;
                                          rout[rtop] = rin[i];        
                                      }
                                      else rout[++rtop] = rin[i];
                                      
                                    }
                             
                             }
                        i ++;
                     }
          }
         while (rtop)
          {
                stack[++top].ch = rout[rtop--];
                stack[top].digit = false;
          }
   /*      for (i = 1;i <= top; i++)
          {
              if (stack[i].digit)
                 printf("%.0lf\n",stack[i].x);
              else printf("%c\n",stack[i].ch);
          }*/
          ttop = 0; i = 1;
          bool flag = true;
          while (i <= top && flag)
          {
                if (stack[i].digit)
                   tst[++ttop] = stack[i].x;
                else {
                        double b = tst[ttop--], a = tst[ttop];
                        switch (stack[i].ch)
                        {
                               case '+': tst[ttop] = a + b;
                                         break;
                               case '-': tst[ttop] = a - b;
                                         break;
                               case '*': tst[ttop] = a * b;
                                         break;
                               case '/': if (fabs(b) < 0.00000001)
                                               flag = false;
                                         else tst[ttop] = a / b;
                                         break;
                               case '^': tst[ttop] = pow(a,b);
                                         break;
                        }
                     }
                i++;
          }
          if (flag)
             printf("%.8lf\n",tst[ttop]);
          else printf("The teacher is so lazy!\n"); 
    }
    return 0;
}

acronix 2010-09-03 21:53 发表评论

KM最佳匹配的模板

acronix — Sat, 21 Aug 2010 10:01:00 GMT

以下为KM算法模板：

//boj1080 
/*=================================================*\
| 二分图最佳匹配（kuhn munkras 算法O(m*m*n)）
| 邻接距阵形式,复杂度O(m*m*n) 返回最佳匹配值,传入二分图大小n,m
| 邻接距阵map,表示权, match返回一个最佳匹配,未匹配顶点
| match值为-1, 一定注意m<=n,否则循环无法终止,最小权匹配可将权值
| 取相反数

\*==================================================*/
#include <cstdio>
#include <memory.h>
const int inf = 0x7fffffff;

int map[25][25],n,lx[25],ly[25],match[25];
bool x[25],y[25];

/************* 寻找增广路******************************/
bool SearchPath(int u)
{
     x[u] = true;  //x注意标记已匹配 
     for (int v = 1; v <= n; v++)
      if(!y[v] && ly[v] + lx[u] == map[u][v])
      {
          y[v] = true;
          if (match[v] == -1 || SearchPath(match[v]))
          {
              match[v] = u;
              return true;
          }
      }
      return false;
}

int KM()
{
    int i,j,k,d;
    for (i = 1; i <= n; i++)
    while(1)
    {
        memset(x,false,sizeof(x));
        memset(y,false,sizeof(y));
        if (SearchPath(i)) //找到完美匹配子图 
           break;
        d = inf;
        for (j = 1; j <= n; j++)
          if (x[j])
          {
                for (k = 1; k <= n; k++)
                 if (!y[k])
                    if (d > lx[j] + ly[k] - map[j][k]) 
                       d = lx[j] + ly[k] - map[j][k];   
          }
        for (j = 1; j <= n;j ++) //降低阶梯 
        {
            if (x[j])  lx[j] -= d;
            if (y[j])  ly[j] += d;
        }                
    }      
    int ans = 0;
    for (i = 1; i <= n; i++)
        ans += map[match[i]][i];   
    return ans;
}

        /**********************************************/

int main()
{
    int i,j,k,v;
    while (scanf("%d",&n) != EOF)
    {
          for (i = 1; i <= n; i++)
              for (j = 1; j <= n; j++)
              {
                  scanf("%d", &v);
                  map[i][j] = -v;
              }
              
/************** 顶标坐标初始化
       ly[i]初始化为0，lx[i]初始化为与i相邻边权最大的值 
     ********************************/
          memset(ly,0,sizeof(ly));
          for (i = 1; i <= n; i++)
          {
              lx[i] = -inf;
              for (j = 1; j <= n; j ++)
                if (lx[i] < map[i][j])
                   lx[i] = map[i][j];
          }
          memset(match,-1,sizeof(match));
          printf("%d\n",-KM());
/******************************************/

    }
    return 0;
}

同时BOJ 1084也是一个很裸的求二分图最佳匹配的问题。

acronix 2010-08-21 18:01 发表评论

poj_2195 Going Home(KM最佳匹配)

acronix — Sat, 21 Aug 2010 09:51:00 GMT

题意：给一个n*m的方块矩阵，人和房子散乱的分布在上边，人数和房子数相等，现在要人都一动到房子里去，一人一房，人每一动一格花费为 1，问要全部人到达各自的房子的最少花费。

分析：转化为二分图最佳匹配，一边为人，一边为房子，他们之间的边权为负花费。再使用KM算法求得边权为负的最佳匹配，再取反极为最小花费了，轻松解决。

cpp代码：

acronix 2010-08-21 17:51 发表评论

poj_1469 COURSES(全裸的二分匹配)

acronix — Sat, 21 Aug 2010 06:43:00 GMT

题目就不说和分析了；
直接
cpp 代码：

acronix 2010-08-21 14:43 发表评论

poj_Machine Schedule(匈牙利算法初步)

acronix — Sat, 21 Aug 2010 05:34:00 GMT

题意：就不多说了。

分析：（转的有图有真相吗）这个题目如果知道使用二分图的话就很简单了，关键就是如何构图。

依照题目意思能够构造出图(1)，转变为图(2)之后发现，之前的job一定在图2中的某一条边上，同一条边上可以包含多个job，所以要完成所有的job，只需要包含所有的边即可，这就是最小点覆盖问题了。又知道二分图的最小点覆盖数=最大匹配数，因此可以用匈牙利算法求。（详细二分图关系见：）

cpp代码：

acronix 2010-08-21 13:34 发表评论

hdu_3256 Computer Assembling(一起来感受dinic的魅力吧)

acronix — Fri, 20 Aug 2010 10:20:00 GMT

题意：电脑装机，要买 N 个配件，现有两家公司A 、B分别有这些配件，但价格不同，现在要求买完配件所用最少的价钱，同时若两配件来自不同的公司，考虑兼容性，可能要花而外的钱买转换器。

分析：最小割转换到最大流，n个配件，n个顶点，源点连向各顶点的边表示A公司的配件，边权表示A公司的该配件的价钱;各顶点连向汇点的边表示B公司的配件，边权表示B公司的该配件的价格。当两配件来自不同公司有兼容性问题时，对应的顶点连双向边，边权为转换器的价格。构图完成，很显然，此图的最小割便是所求，因而可用求最大流即可。

收获：因为此题数据顶点和边的数量都很大，朴素的最大流勉强能应付，但用dinic求最大流，那速度可是相当的快，几倍的差别，甚至是TLE 和 AC的差别。所以好好用好魅力无穷的Dinic吧~~~

cpp代码：

#include <cstdio>
#include <algorithm>
using namespace std;

const int inf = 1<<28;

#define Max 510
int flow[Max][Max],d[Max]; //flow is the network
int sta,end,N,n,m; //sta is the sourse ,end is the end,N is the number of vector
int q[Max];

bool bfs(int s)
{
       int front=0,rear=0; 
       
       for (int i = 0; i <= end; i++) //d[] is the deep
           d[i] = -1;
       q[rear++]=s;  d[s]=0;
       while(front<rear)
       {
               int k=q[front++];
               for(int i=0; i<=N; i++)
                  if(flow[k][i]>0&&d[i]==-1){
                     d[i]=d[k]+1;
                     q[rear++]=i;
                  }
       }
       if(d[end]>=0)   return true;
       return false;
}

int dinic(int k,int sum)  //k is the sourse
{
      if (k==end)    return sum;
      int os = sum;
      for(int i=0;i<=N&&sum;i++)
        if(d[i]==d[k]+1&&flow[k][i]>0)
        {
                int a=dinic(i,min(sum,flow[k][i])); //Deep to the end.
                flow[k][i] -= a;
                flow[i][k] += a;
                sum -= a;
        }
      return os-sum;
}

int main()
{
    int i,j,x,y,v;
    while (scanf("%d %d",&n,&m) != EOF)
    {
          sta = 0; end = n+1;
          for (i = 0; i <= end; i++)
              for (j = 0; j <= end; j++)
                  flow[i][j] = 0;
                  
          for (i = 1; i <= n; i++)
              scanf("%d",&flow[sta][i]);
          for (i = 1; i <= n; i++)
              scanf("%d",&flow[i][end]);
          for (i = 1; i <= m; i++)
          {
              scanf("%d %d %d", &x, &y, &v);
              flow[x][y] = flow[y][x] += v;   
          }
          
          int ret=0;
          N = end;
          while(bfs(sta))
             ret += dinic(sta,inf);
          printf("%d\n",ret);
    }
    return 0;
}

acronix 2010-08-20 18:20 发表评论

poj_1149 PIGS(值得一做的最大流)

acronix — Fri, 20 Aug 2010 08:35:00 GMT

以下解析来自：http://imlazy.ycool.com/post.2059102.html

PKU 1149， PIGS，构造网络流模型时，要注意合并节点和边

这道题目的大意是这样的：

有 M 个猪圈（M ≤ 1000），每个猪圈里初始时有若干头猪。
一开始所有猪圈都是关闭的。
依次来了 N 个顾客（N ≤ 100），每个顾客分别会打开指定的几个猪圈，从中买若干头猪。
每个顾客分别都有他能够买的数量的上限。
每个顾客走后，他打开的那些猪圈中的猪，都可以被任意地调换到其它开着的猪圈里，然后所有猪圈重新关上。

    问总共最多能卖出多少头猪。

    举个例子来说。有 3 个猪圈，初始时分别有 3、 1 和 10 头猪。依次来了 3 个顾客，第一个打开 1 号和 2 号猪圈，最多买 2 头；第二个打开 1 号和 3 号猪圈，最多买 3 头；第三个打开 2 号猪圈，最多买 6 头。那么，最好的可能性之一就是第一个顾客从 1 号圈买 2 头，然后把 1 号圈剩下的 1 头放到 2 号圈；第二个顾客从 3 号圈买 3 头；第三个顾客从 2 号圈买 2 头。总共卖出 2 + 3 + 2 = 7 头。□

    不难想像，这个问题的网络模型可以很直观地构造出来。就拿上面的例子来说，可以构造出图 1 所示的模型（图中凡是没有标数字的边，容量都是 +∞）：

三个顾客，就有三轮交易，每一轮分别都有 3 个猪圈和 1 个顾客的节点。
从源点到第一轮的各个猪圈各有一条边，容量就是各个猪圈里的猪的初始数量。
从各个顾客到汇点各有一条边，容量就是各个顾客能买的数量上限。
在某一轮中，从该顾客打开的所有猪圈都有一条边连向该顾客，容量都是 +∞。
最后一轮除外，从每一轮的 i 号猪圈都有一条边连向下一轮的 i 号猪圈，容量都是 +∞，表示这一轮剩下的猪可以留到下一轮。
最后一轮除外，从每一轮被打开的所有猪圈，到下一轮的同样这些猪圈，两两之间都要连一条边，表示它们之间可以任意流通。

图 1

    不难想像，这个网络模型的最大流量就是最多能卖出的数量。图中最多有 2 + N + M × N ≈ 100,000 个节点。□

    这个模型虽然很直观，但是节点数太多了，计算速度肯定会很慢。其实不用再想别的算法，就让我们继续上面的例子，用合并的方法来简化这个网络模型。

    首先，最后一轮中没有打开的猪圈就可以从图中删掉了，也就是图 2 中红色的部分，显然它们对整个网络的流量没有任何影响。

图 2

    接着，看图 2 中蓝色的部分。根据我总结出的以下几个规律，可以把这 4 个点合并成一个：

    规律 1. 如果几个节点的流量的来源完全相同，则可以把它们合并成一个。

    规律 2. 如果几个节点的流量的去向完全相同，则可以把它们合并成一个。

    规律 3. 如果从点 u 到点 v 有一条容量为 +∞ 的边，并且 u 是 v 的唯一流量来源，或者 v 是 u 的唯一流量去向，则可以把 u 和 v 合并成一个节点。

    根据规律 1，可以把蓝色部分右边的 1、 2 号节点合并成一个；根据规律 2，可以把蓝色部分左边的 1、 2 号节点合并成一个；最后，根据规律 3，可以把蓝色部分的左边和右边（已经分别合并成了一个节点）合并成一个节点。于是，图 2 被简化成了图 3 的样子。也就是说，最后一轮除外，每一轮被打开的猪圈和下一轮的同样这些猪圈都可以被合并成一个点。

图 3

接着，根据规律 3，图 3 中的蓝色节点、2 号猪圈和 1 号顾客这三点可以合并成一个；图 3 中的两个 3 号猪圈和 2 号顾客也可以合并成一个点。当然，如果两点之间有多条同向的边，则这些边可以合并成一条，容量相加，这个道理很简单，就不用我多说了。最终，上例中的网络模型被简化成了图 4 的样子。□

图 4

让我们从图 4 中重新总结一下构造这个网络模型的规则：

每个顾客分别用一个节点来表示。
对于每个猪圈的第一个顾客，从源点向他连一条边，容量就是该猪圈里的猪的初始数量。如果从源点到一名顾客有多条边，则可以把它们合并成一条，容量相加。
对于每个猪圈，假设有 n 个顾客打开过它，则对所有整数 i ∈ [1, n)，从该猪圈的第 i 个顾客向第 i + 1 个顾客连一条边，容量为 +∞。
从各个顾客到汇点各有一条边，容量是各个顾客能买的数量上限。

    拿我们前面一直在讲的例子来说：1 号猪圈的第一个顾客是 1 号顾客，所以从源点到 1 号顾客有一条容量为 3 的边；1 号猪圈的第二个顾客是 2 号顾客，因此从 1 号顾客到 2 号顾客有一条容量为 +∞ 的边；2 号猪圈的第一个顾客也是 1 号顾客，所以从源点到 1 号顾客有一条容量为 1 的边，和之前已有的一条边合并起来，容量变成 4；2 号猪圈的第二个顾客是 3 号顾客，因此从 1 号顾客到 3 号顾客有一条容量为 +∞ 的边；3 号猪圈的第一个顾客是 2 号顾客，所以从源点到 2 号顾客有一条容量为 10 的边。□

    新的网络模型中最多只有 2 + N = 102 个节点，计算速度就可以相当快了。可以这样理解这个新的网络模型：对于某一个顾客，如果他打开了猪圈 h，则在他走后，他打开的所有猪圈里剩下的猪都有可能被换到 h 中，因而这些猪都有可能被 h 的下一个顾客买走。所以对于一个顾客打开的所有猪圈，从该顾客到各猪圈的下一个顾客，都要连一条容量为 +∞ 的边。

    在面对网络流问题时，如果一时想不出很好的构图方法，不如先构造一个最直观，或者说最“硬来”的模型，然后再用合并节点和边的方法来简直化这个模型。经过简化以后，好的构图思路自然就会涌现出来了。这是解决网络流问题的一个好方法。

    代码就不贴了，网络流的题目还是重在建模和思维转化。

acronix 2010-08-20 16:35 发表评论

poj_1459 Power Network

acronix — Wed, 18 Aug 2010 13:37:00 GMT

先上代码：

#include <cstdio>
#include <algorithm>
#include <memory.h>
#include <string.h>
using namespace std;
const int inf = 0x7ffffff;

#define Max 410
int flow[Max][Max],d[Max]; //flow is the network
int sta,end,N; //sta is the sourse ,end is the end,N is the number of vector

bool bfs(int s)
{
       int front=0,rear=0; 
       int q[Max];
       memset(d,-1,sizeof(d));  //d[] is the deep
       q[rear++]=s;  d[s]=0;
       while(front<rear)
       {
               int k=q[front++];
               for(int i=0;i<=N;i++)
                  if(flow[k][i]>0&&d[i]==-1){
                     d[i]=d[k]+1;
                     q[rear++]=i;
                  }
       }
       if(d[end]>=0)   return true;
       return false;
}

int dinic(int k,int sum)  //k is the sourse
{
      if (k==end)   
          return sum;
      int os = sum;
      for(int i=0;i<=N&&sum;i++)
        if(d[i]==d[k]+1&&flow[k][i]>0)
        {
                int a=dinic(i,min(sum,flow[k][i])); //Deep to the end.
                flow[k][i] -= a;
                flow[i][k] += a;
                sum -= a;
        }
      return os-sum;
}

int main()
{
    int i,j,n,np,nc,m;
    int x,y,v;
    char s[20],*p;
    while (scanf("%d %d %d %d",&n,&np,&nc,&m) != EOF)
    {
          sta = n;  end = N = n + 1;
          memset(flow,0,sizeof(flow));
          for (i = 1; i <= m; i++)
          {
              scanf("%s",s);
              p = s + 1;
              sscanf(p,"%d",&x);
              p = strchr(p,',') + 1;
              sscanf(p,"%d",&y);
              p = strchr(p,')') + 1;
              sscanf(p,"%d",&v); 
              flow[x][y] += v;
          }
          for (i = 1; i <= np; i++)
          {
              scanf("%s",s);
              p = s + 1;
              sscanf(p,"%d",&x);
              p = strchr(p,')') + 1;
              sscanf(p,"%d",&v);
              flow[sta][x] = v;
          }
          for (i = 1; i <= nc; i++)
          {
              scanf("%s",s);
              p = s + 1;
              sscanf(p,"%d",&x);
              p = strchr(p,')') + 1;
              sscanf(p,"%d",&v);
              flow[x][end] = v;
          }
         int ret = 0;
         while(bfs(sta))
             ret += dinic(sta,inf);
         printf("%d\n",ret); 
    }
    return 0;
}

acronix 2010-08-18 21:37 发表评论

poj_1087 A Plug for UNIX（dinic模板完美使用）

acronix — Wed, 18 Aug 2010 12:07:00 GMT

题意：n个接口不同的插板，m个有用电器有各自的接口，k种可进行接口转换的适配器（数量不限），问最少多少个用电器不能用电（同时）。

分析：直接转换为典型的最大流问题，源点汇点自定，不同类型接口的插板与汇点相连权值为1；用电器与源点相连，权值为一；适配器的接口之间相连，权值为无穷大。建完图后，dinic模板一贴，完美解决。
注意：接口类型为字符串，用map映射转换。

cpp代码：

#include<iostream>
#include <cstdio>
#include <map>
#include <string>
#include <memory.h>
using namespace std;
map <string,int> mp;
const int inf = 0x7ffffff;

#define Max 605
int flow[Max][Max],d[Max],cnt; //flow is the network
int sta,end,N; //sta is the sourse ,end is the end,N is the number of vector

bool bfs(int s)
{
       int front=0,rear=0; 
       int q[Max];
       memset(d,-1,sizeof(d));  //d[] is the deep
       q[rear++]=s;  d[s]=0;
       while(front<rear)
       {
               int k=q[front++];
               for(int i=0;i<=N;i++)
                  if(flow[k][i]>0&&d[i]==-1){
                     d[i]=d[k]+1;
                     q[rear++]=i;
                  }
       }
       if(d[end]>=0)   return true;
       return false;
}

int dinic(int k,int sum)  //k is the sourse
{
      if (k==end)   
          return sum;
      int os = sum;
      for(int i=0;i<=N&&sum;i++)
        if(d[i]==d[k]+1&&flow[k][i]>0)
        {
                int a=dinic(i,min(sum,flow[k][i])); //Deep to the end.
                flow[k][i] -= a;
                flow[i][k] += a;
                sum -= a;
        }
      return os-sum;
}

int main()
{
    int i,j,n,m,k;
    char s[30],se[30];
    sta = 0; end = N = Max - 1;
    while (scanf("%d",&n) != EOF)
    {
         memset(flow,0,sizeof(flow));
         mp.clear();
         cnt = 0;
         //读入插座类型 
         for (i = 1; i <= n; i++)
         {
             scanf("%s",s);
             if (mp.count(s) == 0)
                 mp[s] = ++cnt;
             flow[mp[s]][end] ++;
         } 
         //读入用电器类型 
         scanf("%d",&m);
         for (i = 1; i <= m; i++)
         {
             scanf("%s",s);
             scanf("%s",s);
             if (mp.count(s) == 0)
                mp[s] = ++cnt;
             flow[sta][mp[s]] ++;
         }
         //读入适配器类型 
         scanf("%d",&k);
         for (i = 1; i <= k; i++)
         {
             scanf("%s %s",s,se);
             if (mp.count(s) == 0)
                mp[s] = ++cnt;
             if (mp.count(se) == 0)
                mp[se] = ++cnt;
             flow[mp[s]][mp[se]] = inf;
         }
         
         int ret = 0;
         while(bfs(sta))
             ret += dinic(sta,inf);
         printf("%d\n",m - ret); 
    } 
    
    return 0;
}

acronix 2010-08-18 20:07 发表评论

hdu_3532

acronix — Wed, 18 Aug 2010 08:44:00 GMT

题意：找最小角中的最大角，具体见题

分析：纯枚举A选的点，计算此点能得到的最小角，枚举完后取最大。
主要用到atan2(y,x)求(0,0)与(x,y)的连线与0-x轴的弧度[-PI , PI].
PI = acos(-1.0).

cpp代码：

#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
const double PI = acos(-1.0);

double  x[1010],y[1010],MAX,MIN;
double  d[1010];
int n;

inline double myatan2(double y,double x)
{
       double t = atan2(y,x);
     //  printf("%lf\n",t >= 0 ? t : t + 2*PI);
       return t >= 0 ? t : t + 2*PI;
}

int main()
{
    int i,j,k,cnt;
    while (scanf("%d",&n) && n >= 3)
    {
          MAX = -1.0;
          for (i = 1; i <= n; i++)
              scanf("%lf %lf",&x[i],&y[i]);
          for (i = 1; i <= n; i++)
          {
              MIN = PI;
              cnt = 0;
              for (j = 1; j <= n; j ++)
                  if (j != i)
                    d[++cnt] = myatan2(y[j]-y[i],x[j]-x[i]);
              sort(d+1,d+cnt+1);
              for (k = 2; k <= cnt; k++)
                  if (MIN > d[k]-d[k-1])
                     {
                         MIN = d[k] - d[k-1]; 
                       
                     }
              double temp = (2*PI - (d[cnt] - d[1]));
              if (MIN > temp)
                {
                    MIN = temp;
                }
               if (MIN > MAX)
                  MAX = MIN;  
          }
          printf("%.4lf\n",(MAX*180)/PI);
    }
    return 0;
}

acronix 2010-08-18 16:44 发表评论

hdu_3512

acronix — Wed, 18 Aug 2010 08:37:00 GMT

题意：最小二分图匹配的变形，边的权值为两定点的乘积，求匹配中的最大乘积最小。

分析：首先，两组数据中全为正时，只有大乘小才能得到最大中的最小。
明白这点后，分析两组数据的情况，都为正，都为负，一负一正，部分负部分正，考虑清楚，并想出对应的解法即可。还有就是0既可以看成负数，也可看成正数。

#include <cstdio>
#include <stdlib.h>
#include <algorithm>
using namespace std;
const long long  inf = -1LL<<60;

long long a[100010],b[100010];
int xa,xb,ya,yb;
int n;

int main()
{  
    int i,j,k;
    long long max;
    while (scanf("%d",&n) != EOF)
    {
          max = inf;
          
          xa = xb = ya = yb = 0;
          for (i = 1; i <= n; i++)
          {
             scanf("%I64d",&a[i]);
             if (a[i] <= 0)
                ya ++;
             else xa ++;
          }
          for (i = 1; i <= n; i++)
          {
              scanf("%I64d",&b[i]);
              if (b[i] <= 0)
                 yb ++;
              else xb ++;
          }
          sort(a+1,a+1+n);
          sort(b+1,b+1+n);
          //a，b全为正 
          if ((xa == n && xb == n) ||(xa == 0 && xb == 0))
          {
                  for (i = 1; i <= n; i++)
                      if (max < a[i]*b[n-i+1])
                         max = a[i]*b[n-i+1];
                  printf("%I64d\n",max);
                  continue;
          }
          //a，b一正一负 
          if ((xa == n && xb == 0) || (xa == 0 && xb == n))
          {
                  for (i = 1; i <= n; i++)
                      if (max < a[i]*b[i])
                         max = a[i]*b[i];
                  printf("%I64d\n",max);
                  continue;
          }
          //a全为正
          if (xa == n)
          {
                 for (i = 1; i <= xb;i++)
                     if (max < a[i]*b[n-i+1])
                       max = a[i]*b[n-i+1];
                 printf("%I64d\n",max);
                 continue;
          } 
          //a全为负 
          if (xa == 0)
          {
                 for (i = 1; i <= yb; i++)
                     if (max < a[n-i+1]*b[i])
                        max = a[n-i+1]*b[i];
                printf("%I64d\n",max);
                continue;
          }
           //b全为正
          if (xb == n)
          {
                 for (i = 1; i <= xa;i++)
                     if (max < b[i]*a[n-i+1])
                       max = b[i]*a[n-i+1];
                 printf("%I64d\n",max);
                 continue;
          } 
          //b全为负 
          if (xb == 0)
          {
                 for (i = 1; i <= ya; i++)
                     if (max < b[n-i+1]*a[i])
                        max = b[n-i+1]*a[i];
                printf("%I64d\n",max);
                continue;
          }
          //a的正==b的负 
          if (xa == yb)
          {
                 for (i = 1; i <= ya; i++)
                     if (max < a[i]*b[yb+i])
                        max = a[i]*b[yb+i];
                 for (i = 1; i <= yb; i++)
                     if(max < b[i]*a[ya+i])
                            max = b[i]*b[yb+i];       
                 printf("%I64d\n",max);
                 continue;
          }
          //a的正 》b的负，余下全为正 
          if (xa > yb)
          {
                 for (i = ya+1,j = n - ya; i <= n-yb; i++,j--)
                     if (max <a[i]*b[j])
                        max = a[i]*b[j];
                 printf("%I64d\n",max);
                 continue; 
          } 
          //a的正小于b的负，余下全为负 
          if (xa < yb)
          {
                 for (i = xb+1,j = n- xb; i <= n - xa; i++,j--)
                     if (max < a[i]*b[j])
                        max = a[i]*b[j];
                 printf("%I64d\n",max);
                 continue;
          }           
    }
    return 0;
}

acronix 2010-08-18 16:37 发表评论

hdu_3531 Match

acronix — Mon, 16 Aug 2010 11:21:00 GMT

摘要: 题意：给你两个0-1矩阵，编程验证后一个矩阵是不是前一个矩阵的一部分。分析：解法一：在N*N中枚举M*M大小矩阵的左上角，然后比较这部分的矩阵行列的1个数是否相等，若全相等则一一比较。用C++交，压着时间过。解法二：字符串匹配的Rabin_Karp算法的二维拓展。下面是摘要RK算法的描述：1. 问题描述给定目标字符串 T[... 阅读全文

acronix 2010-08-16 19:21 发表评论

hdu_3528 The Simple Programming Language

acronix — Mon, 16 Aug 2010 05:26:00 GMT

题意：给你一串只含有关键字write，if，else的语句，要你编程处理并输出结果，无结果则不输出

分析：本题最大的难点就是对字符串的处理。
首先，以if() ..... else ..... 为基结构，碰到write("....")便输出。而碰到嵌套语句.....不断利用递归调用寻找基语句。同时，注意if(0)的情况，在if(0).....else之间的.....通通略过。我做的时候，碰到问题有换行，处理空格，以及对字符串末尾的'\0'的处理。棘手的就是要清楚的看到指针变换的过程与指向位置。

#include <cstdio>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

char s[5000],cmd[20];

void work(char *p)
{
     sscanf(p,"%s",cmd);
     char *q = cmd;
     if (cmd[0] == 'w')   //当keyword == "write" 
     {
        while (*q != '"')    q ++;  
        q ++;
        while (*q != '"')
        {
              putchar(*q);   q ++; 
        }
        putchar('\n');
        while (s[0] != '\0')
              gets(s);
     }
     else if (cmd[0] = 'i') //当 key words == "if" 
          {
             while (*p != '(')  p ++;
             p ++;
             
             if (*p == '1')//当为true时 
             {
                    p = strchr(p,' ');
                    
                    while  (p != NULL &&*p == ' ')  p ++;
                    if (p == NULL)
                    {
                       gets(s); 
                       if (s[0] != '\0')
                          work(s);
                       else return ;   
                    }
                    else work(p);
             }
             else{     //当为false时 
                     int cnt = 0;
                     
                     //一个 do-while循环忽略if(0)..else之间的语句 
                     do{
                       p = strchr(p,' ');
                      
                       while (p != NULL && *p == ' ')
                            p ++;
                       
                       if (p == NULL || *p == '\0')
                       {
                           gets(s);
                           if (s[0] == '\0')
                              return ;
                           p = s;
                       }
                       sscanf(p,"%s",cmd);
                       if (cmd[0] == 'i')
                         cnt ++;
                       else if (cmd[0] == 'e')
                                cnt --;
                       while (p != NULL && *p == ' ')
                            p ++;
                     }while (cnt >= 0);
                     p = strchr(p,' ');
                     while  (p!= NULL && *p == ' ')  
                        p ++;
                        
                     if (p == NULL || *p == '\0')
                       {
                           gets(s);
                           if (s[0] == '\0')
                              return ;
                           p = s;  
                       } 
                    
                     work(p);
                     
                  }
          }
          else {//当key words为else 
                   p = strchr(p,' ');
                   while  (p != NULL && *p == ' ')  p ++;
                   if (p == NULL || *p == '\0')
                       {
                           gets(s);
                           if (s[0] == '\0')
                              return ;
                           p = s;
                       } 
                   work(p);
                   
               }
}

int main()
{
    while (gets(s) && s[0] != '\0')
    {
          work(s);
    }
    return 0;
}

acronix 2010-08-16 13:26 发表评论

hdu_3534 Tree

acronix — Sun, 15 Aug 2010 12:42:00 GMT

题意：给你一棵树，求最长的路程及其数目。

分析：这道题做的我好辛苦啊，说是树形dp，我的理解此题其实是个树形递推（自顶向下使用递归实现自底向上的递推），唯一的记忆话就是标记访问过的节点，防止倒退。
        理解了这个，还有一个难点，就是计数的问题：当有过某个节点有多个最大值时的计数；当子树有相同最大值的计数的补充。
        总之，trick多多。还有本题可由任一节点开始递归，并不影响树的性质，倒是要注意第二种计数情况！！

#include <cstdio>
#include <stdlib.h>

const int MAX = 10010;

struct Point{
       int id,len;
       struct Point *next;
} p[2*MAX],*head[MAX]; 

struct Recd{
       bool flag;//标记 
       int max,num; //当前节点以下的所有最大值及数目 
       int max_rout;//以此节点为端点的最大值 
       int max_num; //以此节点为端点的最大值的数目 
} a[MAX]; //记录各顶点的状态 

int n,x,y,v,cnt;

inline void addedge(int x,int y,int v)//用邻接表把各节点串起来 
{
       cnt ++;
       p[cnt].id = y;
       p[cnt].len = v;
       p[cnt].next = head[x];
       head[x] = &p[cnt];
}

void dp(int root)
{
     a[root].flag = true;
     struct Point *q = head[root];
     
     int m[2] = {0,0};
     int m_cnt[2] = {1,1};
     bool mark = false;
     int son_max = -1 , son_num = 0;
     int tnum[2] = {0,0};
     
     while (q)
     {
           if (a[q->id].flag == true)//已访问过 
           {
              q = q->next;
              continue;
           }
           dp(q->id);
           x = a[q->id].max_rout + q->len;
           y = a[q->id].max_num;
           if (x > m[0])
           {
                 mark = false;
                 m[1] = m[0];
                 m_cnt[1] = m_cnt[0];
                 m[0] = x;
                 m_cnt[0] = y;
                 tnum[0] = 0; //pay attention 
           }
           else if (x == m[0])
                {
                      mark = true;
                      tnum[0] += m_cnt[0]*y;
                      m_cnt[0] += y;
                }
                else if (x > m[1])
                     {
                           m[1] = x;
                           m_cnt[1] = y;
                     }
                     else if(x == m[1])
                           {
                               m_cnt[1] += y;
                           }
                 
           if (son_max < a[q->id].max)
           {
              son_max = a[q->id].max;
              son_num = a[q->id].num;
           }
           else if (son_max == a[q->id].max)
                   son_num += a[q->id].num;
           q = q->next;
     }
     int temp ,sum;
     if (mark)
     {
              sum = tnum[0];
              temp = 2*m[0];
     }
     else {
          temp = m[0] + m[1];
          sum = m_cnt[0] * m_cnt[1];
          }
     
     if (temp < son_max)
     {
        temp = son_max;
        sum = son_num;
     }
     else if (temp == son_max)//pay attention
          {
                   sum += son_num;
          }
     
     a[root].max_rout = m[0];
     a[root].max_num = m_cnt[0];
     a[root].max = temp;
     a[root].num = sum;
}

int main()
{
    while (scanf("%d",&n) != EOF)
    {
          for (int i = 1; i <= n; i++)
          {
              a[i].flag = false;
              head[i] = NULL;
          }
          cnt = 0;
          for (int i = 1; i < n; i++)
          {
              scanf("%d %d %d",&x,&y,&v);
              addedge(x,y,v);
              addedge(y,x,v);
          }
        
          dp(1);
         printf("%d %d\n",a[1].max,a[1].num);
    }
    return 0;
} 

acronix 2010-08-15 20:42 发表评论