bzoj usaco 金组水题题解（1）

UPD:我真不是想骗访问量TAT。。一开始没注意总长度写着写着网页崩了王仓（其实中午的时候就时常开始卡了= =）。。。。损失了2h(幸好长一点的都单独开了一篇)。。。。吓得赶紧分成两坨。。。。TAT。。。。。。。。。。。。。。

——————————————————————————————————————————————————————————————————————————————

　　写（被虐）了整整一个月b站上usaco的金组题。。。然而到现在总共只写了100道上下TAT（当然是按AC人数降序排列的了）（另外，是用云神的号写的= =毕竟三百大洋）

　　大概不到13是自己写的，一半是有大概方向后跑去看题解，剩下的就是毫无思路就去看题解作死的了= =

　　感觉金组题还是比较适合自己当前水平的QAQ。。。所以大致的写下题解加深下印象吧。。。对于比较经典而自己又不熟的题打算专门另写题解（瞬间就挖了一个大坑）

这里贴出50道。。。

bzoj 1597:[Usaco2008 Mar]土地购买    

　　斜率优化入门题。f[i]表示买前i块土地的最小费用

　　f[i]=min{
　　　　　　f[j]+max_w(j+1,i)*max_l(j+1,i)，（ 0<=j<i ）
　　}// max_w(j+1,i)和max_l(j+1,i)分别表示第j+1块土地到第i块土地中宽度和长度的最大值

　　首先去掉那些被别的土地完全覆盖的土地（因为不会对答案有任何影响），剩下的按宽度排序。宽度升序排序的话，长度一定是降序的（被完全覆盖的都被去掉了）

　　方程就变成  f[i]=min{  f[j]+wid[i]*len[j+1]  }，（0<=j<i）

　　剩下的就是斜率优化了。。。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#define d double
#define ll long long
using namespace std;
const int maxn=50023;
struct zs{
    int x,y;
}a[maxn];
bool cant[maxn];
ll f[maxn];
int l,r,dl[maxn];
int i,j,k,n,m;
char rx;int ra;
 
 
bool cmp(zs a,zs b){return a.x<b.x||(a.x==b.x&&a.y>b.y);
}
bool smaller(int aa,int b,int c){
    return  (ll)(f[c]-f[b])*(ll)(a[aa+1].y-a[b+1].y) <= (ll)(f[b]-f[aa])*(ll)(a[b+1].y-a[c+1].y);
    /*return (d)(f[i]-f[dlr])/(d)(a[dlr+1].y-a[i+1].y)
            <
           (d)(f[dlr]-f[pre])/(d)(a[pre+1].y-a[dlr+1].y);*/
}
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
int main(){
    n=read();
    for(i=1;i<=n;i++)a[i].x=read(),a[i].y=read();
    sort(a+1,a+1+n,cmp);int tmp=a[n].y;
    for(i=n-1;i;i--)
        if(a[i].y<=tmp)cant[i]=1;else tmp=a[i].y;  tmp=0;
    for(i=1;i<=n;i++)if(!cant[i])a[++tmp].x=a[i].x,a[tmp].y=a[i].y;  n=tmp;
    for(i=1;i<=n;i++){
        while(l<r&&  (ll)(f[dl[l+1]]-f[dl[l]]) < (ll)a[i].x*(ll)(a[dl[l]+1].y-a[dl[l+1]+1].y)  )l++;
        f[i]=f[dl[l]]+(ll)a[i].x*a[dl[l]+1].y;
        while(l<r&& smaller(dl[r-1],dl[r],i))r--;dl[++r]=i;
    }
    printf("%lld
",f[n]);
    return 0;
}

bzoj 1699：[Usaco2007 Jan]Balanced Lineup排队

　　rmq裸题。。。因为不涉及区间修改的操作所以可以用线段树的点树写法（建成一个堆）来写。。。

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int maxn=52333;
int mx[maxn<<2],mn[maxn<<2],a[maxn];
int i,j,k,n,m,len,L,R,ansmax,ansmin;
char s[11];
inline void outx(int x){//len=0;
    while(x||!len)s[len++]=x%10,x/=10;
    while(len)len--,putchar(s[len]+'0');putchar('
');
}
inline void inx(int &x){
    int ch;x=0;
    for(ch=getchar();ch<'0'||ch>'9';ch=getchar());
    for(;ch>='0'&&ch<='9';x=x*10+ch-'0',ch=getchar());;
}
int main(){
    scanf("%d%d",&n,&m);int dep=0;
    while(1<<dep<n)dep++;int stnum=(1<<dep)-1;dep++;
    for(i=1;i<=n;i++)inx(a[i]),mx[stnum+i]=mn[stnum+i]=a[i];
    for(i=stnum;i;i--){
        if(mx[i<<1]>mx[(i<<1)|1])mx[i]=mx[i<<1];else mx[i]=mx[(i<<1)|1];
        if(mn[i<<1]<mn[(i<<1)|1])mn[i]=mn[i<<1];else mn[i]=mn[(i<<1)|1];
    }
    for(i=1;i<=m;i++){
        inx(L);inx(R);ansmax=max(a[L],a[R]);ansmin=min(a[L],a[R]);
        L+=stnum;R+=stnum;if(L==R)outx(0);else{
        for(;(L^R)!=1;L>>=1,R>>=1){
            if(R&1){if(mx[R^1]>ansmax)ansmax=mx[R^1];if(mn[R^1]<ansmin)ansmin=mn[R^1];}
            if(!(L&1)){if(mx[L^1]>ansmax)ansmax=mx[L^1];if(mn[L^1]<ansmin)ansmin=mn[L^1];}
        };outx(ansmax-ansmin);}
         
    }
    return 0;
}

bzoj 1230：[Usaco2008 Nov]lites 开关灯

　　线段树区间修改。。。

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxn=132333;
int num[2][maxn<<1],a[maxn<<1],b[maxn<<1],l[maxn<<1],r[maxn<<1],mid[maxn<<1];
bool rev[maxn<<1];
int i,j,k,n,m,L,R,id,tot;
 
char rx;int ra;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
inline void pushdown(int now,int l,int r){
    rev[l]^=1;rev[r]^=1;
    swap(num[0][l],num[1][l]);swap(num[0][r],num[1][r]);
    rev[now]=0;
}
void change(int now,int a,int b){
    if(L<=a&&R>=b){rev[now]^=1;swap(num[0][now],num[1][now]);return;}
    if(rev[now])pushdown(now,l[now],r[now]);
    if(L<=mid[now])change(l[now],a,mid[now]);
    if(R>mid[now])change(r[now],mid[now]+1,b);
    num[0][now]=num[0][l[now]]+num[0][r[now]];
    num[1][now]=num[1][l[now]]+num[1][r[now]];
}
int query(int now,int a,int b){
    if(L<=a&&R>=b)
        return num[1][now];
    if(rev[now])pushdown(now,l[now],r[now]);
    if(R<=mid[now])return query(l[now],a,mid[now]);
    else if(L>mid[now])return query(r[now],mid[now]+1,b);
    else return query(l[now],a,mid[now])+query(r[now],mid[now]+1,b);
}
void build(int a,int b){
    int now=++tot;
    num[0][now]=b-a+1;mid[now]=(a+b)>>1;
    if(a<b){
        l[now]=tot+1;
        build(a,mid[now]);r[now]=tot+1;
        build(mid[now]+1,b);
    }
}
int main(){
    n=read();m=read();
    build(1,n);
    for(i=1;i<=m;i++){
        id=read();L=read();R=read();
        if(id)printf("%d
",query(1,1,n));else change(1,1,n);
    }
    return 0;
}

bzoj 1666：[Usaco2006 Oct]Another Cow Number Game 奶牛的数字游戏

　　代码长度知一切系列。。直接模拟即可

#include<cstdio>
int n,ans;
int main(){
    for(scanf("%d",&n);n>1;ans++)if(n&1)n=n*3+1;else n>>=1;printf("%d
",ans);
}

bzoj 1724：[Usaco2006 Nov]Fence Repair 切割木板

　　反过来看就是合并果子。。维护小根堆，每次把最短的两段木板并起来，直到变成一段

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#define ll long long
using namespace std;
priority_queue <ll>q;
int i,j,k,n,m;
ll ans,tmp;
 
char rx;int ra;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
int main(){
    n=read();
    for(i=1;i<=n;i++)m=read(),q.push(-m);
    for(i=1;i<n;i++){
        tmp=q.top();q.pop();tmp+=q.top();q.pop();
        ans-=tmp;q.push(tmp);
    }
    printf("%lld
",ans);
    return 0;
}

bzoj 1726：[Usaco2006 Nov]Roadblocks第二短路

　　求严格次短路。。。最短路改一下。。同时记录到达某个点的最短距离和严格次短距离

　　为了压常数把本来的代码长度改长了不少（反正本来也就毫无可读性= =）。。

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxn=5001;
const int maxm=100002;
int dis[2][maxn],last[maxn];
struct zs{
    int too,dis;
    int pre;
}e[maxm<<1];
short dl[23333];
bool u[maxn];
int i,j,k,n,m,a,b,c,tot;
 
inline void insert(short a,short b,short c){
    e[++tot].too=b;e[tot].dis=c;e[tot].pre=last[a];last[a]=tot;
    e[++tot].too=a;e[tot].dis=c;e[tot].pre=last[b];last[b]=tot;
}
char rx;int ra;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
void spfa(){
    int l=0,r=1,now,i,a,b;
    for(i=0;i<2;i++)memset(dis[i],50,(n+1)*4);
    dl[1]=1;u[1]=1;dis[0][1]=0;short j;
    while(l<r){
        now=dl[++l];u[now]=0;
        if(dis[0][now]<dis[1][n])
        for(i=last[now],j=e[i].too,a=dis[0][now]+e[i].dis,b=dis[1][now]+e[i].dis;i;i=e[i].pre,j=e[i].too,a=dis[0][now]+e[i].dis,b=dis[1][now]+e[i].dis)
            if(dis[0][j]>a){
                if(dis[0][j]<b)dis[1][j]=dis[0][j];else dis[1][j]=b;
                dis[0][j]=a;
                if(!u[j])u[j]=1,dl[++r]=j;
            }else if(dis[0][j]<a) 
                    if(a<dis[1][j]){
                        dis[1][j]=a;
                        if(!u[j])u[j]=1,dl[++r]=j;
                    }else;
             else if(dis[0][j]==a&&b<dis[1][j]){
                dis[1][j]=b;
                if(!u[j])u[j]=1,dl[++r]=j;
            }
    }
}
int main(){
    n=read();m=read();
    for(i=1;i<=m;i++)a=read(),b=read(),c=read(),insert(a,b,c);
    spfa();
    printf("%d
",dis[1][n]);
    return 0;
}

bzoj 1231：[Usaco2008 Nov]mixup2 混乱的奶牛

　　题目是要求能使排列混乱的方案数。语死早。。数据范围显然状压。。

　　f[i][j]表示当前已选入列奶牛的状态为i，最后一头牛编号为j的混乱方案数，(0<i<2^n，1<=j<=n)

　　f[0][0]=1;f[i][j]=sum{f[i-2^j][k]}，（S[k]-S[j]的绝对值>K，j存在于状态i中）

#include<cstdio>
#include<iostream>
#include<cstring>
#define ll long long
using namespace std;
const int maxn=16;
ll f[16][(1<<maxn)+3],ans;
int pos[(1<<maxn)+3];
int two[17];
short a[17];
int x,y,x1,yy,j,K;
int mx;
int i,k,n;
bool can[17][17];
int main(){
    scanf("%d%d",&n,&K);for(i=1;i<=n;i++)scanf("%d",&a[i]);
    f[0][0]=1;mx=1<<n;
    for(i=1;i<n;i++)for(j=i+1;j<=n;j++)if(max(a[i]-a[j],a[j]-a[i])>K)can[i-1][j-1]=can[j-1][i-1]=1;
    for(i=1;i<=n;i++)two[i]=1<<(i-1),pos[two[i]]=i-1,f[i-1][two[i]]=1;
    for(j=1;j<=mx&&j>0;j++)
        for(x=j,y=x&(-x),i=pos[y];x;x-=y,y=x&(-x),i=pos[y])
            for(x1=j,yy=x1&(-x1),k=pos[yy];x1;x1-=yy,yy=x1&(-x1),k=pos[yy])if(i!=k&&can[i][k])
            f[k][j]+=f[i][j^yy];
    for(i=0;i<n;i++)ans+=f[i][mx-1];
    printf("%lld
",ans);
    return 0;
}

 

bzoj 1572: [Usaco2009 Open]工作安排Job

　　按截止时间降序排序。也就是时间从大到小枚举，每个时间点安排价值最大、且截止时间在当前时间点之前的工作

　　具体实现就不能一个一个时间点枚举了。。在相邻工作的截止时间之间的时间点，可以完成的工作都是不变的

　　单调队列优化一下。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
#define ll long long
using namespace std;
const int maxn=100003;
struct zs{
    int tim,val;
}a[maxn];
priority_queue<int>q;
int i,j,k,n,m,top;
ll ans;
int ra,size;char rx;
 
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
bool cmp(zs a,zs b){
    return a.tim<b.tim;
}
int main(){
    n=read();
    for(i=1;i<=n;i++)a[i].tim=read(),a[i].val=read();
    sort(a+1,a+1+n,cmp);
     
    for(i=n;i;i--){
        q.push(a[i].val);size++;
        if(a[i].tim-a[i-1].tim>size)j=size;else j=a[i].tim-a[i-1].tim;
        while(j--)ans+=q.top(),q.pop(),size--;
    }
    printf("%lld
",ans);
    return 0;
}

bzoj 1579： [Usaco2009 Feb]Revamping Trails 道路升级

　　分层图最短路。。。dis[i][j]表示到i点，共更新了j条边的最短路径长度。

　　按照更新的边数建K+1层图，第i层表示当前更新了（i-1）条边。除了在本层内扩展外，第1~K层的点还可以向更高的一层扩展（更新当前边为0）

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#define ll long long
using namespace std;
const int maxn=10001;
const int maxm=50001;
const int mx=233333;
struct poi{
    short pos;int dis;short int x;
}tmp;
priority_queue<poi>q;
struct zs{
    short too;
    int dis,pre;
}e[maxm<<1];
int last[maxn],dis[21][maxn];
ll dist[21][maxn],ans;
int i,j,k,n,m,K,tot,a,b;
bool u[21][maxn];
 
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
bool operator <(poi a,poi b){return a.dis>b.dis;} 
void spfa(){
    int l=0,r=1,i;short now;short int nowx;
    for(i=0;i<=K;i++)memset(dist[i],50,(n+1)<<3);
    ans=dist[0][n];
    u[0][1]=1;dist[0][1]=0;
    tmp.dis=0;tmp.pos=1;tmp.x=0;q.push(tmp) ;
    while(!q.empty()){
        tmp=q.top();q.pop();
        now=tmp.pos;nowx=tmp.x;u[nowx][now]=0;
        if(dist[nowx][now]<ans)
        for(i=last[now];i;i=e[i].pre){
            if(dist[nowx][e[i].too]>dist[nowx][now]+e[i].dis){
                dist[nowx][e[i].too]=dist[nowx][now]+e[i].dis;
                if(e[i].too==n)ans=min(ans,dist[nowx][e[i].too]);
                if(!u[nowx][e[i].too]){
                    u[nowx][e[i].too]=1;
                    tmp.pos=e[i].too;tmp.x=nowx;tmp.dis=dist[nowx][e[i].too];
                    q.push(tmp);
                }
            }
            if(nowx<K&&dist[nowx+1][e[i].too]>dist[nowx][now]){
                dist[nowx+1][e[i].too]=dist[nowx][now];
                if(e[i].too==n)ans=min(ans,dist[nowx+1][e[i].too]);
                if(!u[nowx+1][e[i].too]){
                    u[nowx+1][e[i].too]=1;
                    tmp.pos=e[i].too;tmp.x=nowx+1;tmp.dis=dist[nowx+1][e[i].too];
                    q.push(tmp);
                }
            }
        }
    }
}
int main(){
    n=read();m=read();K=read();
    for(i=1;i<=m;i++){
        a=read();b=read();
        e[++tot].dis=e[tot+1].dis=read();
        e[tot].too=b;e[tot].pre=last[a];last[a]=tot++;
        e[tot].too=a;e[tot].pre=last[b];last[b]=tot;
    }
    spfa();
    printf("%lld
",ans);
    return 0;
}

bzoj 1708： [Usaco2007 Oct]Money奶牛的硬币

　　完全背包。。。一开始竟然没看出来王仓

bzoj 1690： [Usaco2007 Dec]奶牛的旅行

　　01分数规划。。。二分答案为mid，将原图的边(u,v,time)重建为(u,v,fun[v]-time*mid)，如果新图中有负环那么当前答案可行

#include<cstdio>
#include<cstring>
#include<iostream>
#define d double
using namespace std;
const int maxn=1021;
const int maxm=5023;
const d eps=1e-5;
struct zs{
    int too,pre,t;
    d dis;
}e[maxm];
int i,j,k,n,m,tot,a,b,c;
d dist[maxn],l,r,mid;
int val[maxn],last[maxn];
bool u[maxn],uu[maxn],flag;
 
inline int read(){
    char x;int ans=0;
    for(x=getchar();x<'0'||x>'9';x=getchar());
    for(;x>='0'&&x<='9';x=getchar())ans*=10,ans+=x-48;
    return ans;
}
inline void insert(int a,int b,int c){
    e[++tot].too=b;e[tot].pre=last[a];e[tot].t=c;last[a]=tot;
}
bool spfa(int x){
    u[x]=1;uu[x]=1;
    for(int i=last[x];i;i=e[i].pre)if(dist[e[i].too]>dist[x]+e[i].dis){
        dist[e[i].too]=dist[x]+e[i].dis;
        if(u[e[i].too]){flag=1;return 1;}
        if(spfa(e[i].too))return 1;
    }
    u[x]=0;
    return 0;
}
bool check(d mid){
    memset(uu,0,n+1);
    memset(u,0,n+1);
    memset(dist,0,4*(n+1));
    flag=0;
    for(int i=1;i<=n;i++)if(!uu[i])if(spfa(i))return 1;
    return 0;
}
int main(){
    n=read();m=read();
    for(i=1;i<=n;i++)val[i]=read();
    for(i=1;i<=m;i++)a=read(),b=read(),c=read(),insert(a,b,c),r=max(r,(d)val[b]/(d)c);
    l=0.0;
    while(l+eps<=r){
        mid=(l+r)/2.0;
        for(i=1;i<=m;i++)e[i].dis=(d)(-val[e[i].too])+mid*e[i].t;
        if(check(mid))l=mid;else r=mid-eps;
    }
    printf("%.2lf
",l);
    return 0;
}

bzoj 1717： [Usaco2006 Dec]Milk Patterns 产奶的模式

　　字符串http://www.cnblogs.com/czllgzmzl/p/4989723.html

bzoj 1692： [Usaco2007 Dec]队列变换

　　贪心。。。当前剩下的队伍为[l,r]，每次比较 l到r 这段字符串和 r到l 这段字符串，哪段小选哪段

　　比较字符串大小的时候可以用hash+二分求出最长公共前缀的长度，再比较下一位的大小

　　hash用unsigned int不会被卡。。。感人。。明显优势#1

　　然而O(n^2)暴力可过TAT

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#define ull unsigned int
using namespace std;
const int maxn=30003;
char s[maxn];
ull pre[maxn],jc[maxn],val1,val2,pre1[maxn];
short i,j,k,n,m,l,r,mid,len,L,R;
 
inline short getlen(){
    if(s[L]!=s[R])return 0;
    l=1;r=R-L+1;
    if(pre[L+r-1]-pre[L-1]*jc[r]==pre1[R-r+1]-pre1[R+1]*jc[r])return r;r--;
    while(l<r){
        mid=(l+r+1)>>1;//return mid;
        val1=pre[L+mid-1]-pre[L-1]*jc[mid];
        val2=pre1[R-mid+1]-pre1[R+1]*jc[mid];
        if(val1!=val2)r=mid-1;else l=mid;
        if(s[L+l]!=s[R-l])return l;
    }
    return l;
}
inline bool bigger(){
    if(s[L]!=s[R])return s[L]>s[R];
    len=getlen();
    if(len==R-L+1)return 1;
    else return s[L+len]>s[R-len];
}
int main(){
    scanf("%d",&n);
    for(i=1;i<=n;i++)for(s[i]=getchar();s[i]<'A'||s[i]>'Z';s[i]=getchar());
    jc[0]=1;for(i=1;i<=n;i++)jc[i]=jc[i-1]*107;
    for(i=1;i<=n;i++)pre[i]=pre[i-1]*107+(ull)s[i]-'A';
    for(i=n;i;i--)pre1[i]=pre1[i+1]*107+(ull)s[i]-'A';
    L=1;R=n;
    for(i=1;i<=n;i++)if(bigger()){
        putchar(s[R--]);
        if(i%80==0)putchar('
');
    }else {putchar(s[L++]);if(i%80==0)putchar('
');}
    return 0;
}

bzoj 1782： [Usaco2010 Feb]slowdown 慢慢游

　　dfs序，一头牛走到点i，相当于将点i所在子树的权值都+1，查询的时候查询牛要走到的点的权值

　　也可以差分，变成点修改+区间查询，用树状数组就行了。。。

　　太傻逼用线段树然后被常数感动哭了

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxn=140233;
struct zs{
    int too,pre;
}e[200122];
int pos[100122],last[100233],size[100233];
int l[maxn<<1],r[maxn<<1],add[maxn<<1],A[maxn<<1],B[maxn<<1],mid[maxn<<1];
int i,j,k,n,m,a,b,c,tim,tot,tott;
int ra;char rx;
 
 
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
inline void insert(int a,int b){
    e[++tot].too=b;e[tot].pre=last[a];last[a]=tot;
    e[++tot].too=a;e[tot].pre=last[b];last[b]=tot;
}
void dfs(int x,int pre){
    size[x]=1;pos[x]=++tim;
    for(int i=last[x];i;i=e[i].pre)if(e[i].too!=pre){
        dfs(e[i].too,x);size[x]+=size[e[i].too];
    }
}
void build(int a,int b){
    int now=++tott;
    A[now]=a;B[now]=b;mid[now]=(a+b)>>1;
    if(a<b){
        l[now]=tott+1;build(a,mid[now]);
        r[now]=tott+1;build(mid[now]+1,b);
    }
}
inline void pushdown(int now){
    add[l[now]]+=add[now];add[r[now]]+=add[now];
    add[now]=0;
}
void insert(int now,int c,int d){
    if(c<=A[now]&&B[now]<=d){add[now]++;return;}
    if(add[now])pushdown(now);
    if(c<=mid[now])insert(l[now],c,d);
    if(d>mid[now])insert(r[now],c,d);
}
int query(int now,int c){
    if(A[now]==B[now])return add[now];
    if(add[now])pushdown(now);
    if(c<=mid[now])return query(l[now],c);else return query(r[now],c);
}
int main(){
    n=read();
    for(i=1;i<n;i++)a=read(),b=read(),insert(a,b);
    dfs(1,0);
    build(1,n);
    for(i=1;i<=n;i++){
        a=read();printf("%d
",query(1,pos[a]));
        insert(1,pos[a],pos[a]+size[a]-1);
    }
}

bzoj 1827： [Usaco2010 Mar]gather 奶牛大集会

　　O(n^2)的暴力就是对每个点都把整棵树遍历一遍

　　考虑一下，假设求出了到当前点i的不方便值为fasum，如何快速计算i的儿子的不方便值

　　先预处理出每个点的子树内奶牛总数存在size[]，那么对于i的某个儿子j，所有不在j的子树里的奶牛都得多走从i->j这段路，而j子树里的奶牛都可以少走i->j这段路

　　nowsum=fasum+(cownum-size[j])*dis(i,j)-size[j]*dis(i,j);

#include<iostream>
#include<cstring>
#include<cstdio>
#define ll long long
using namespace std;
const int maxn=100023;
struct zs{
    int too,pre;
    ll dis;
}e[maxn<<1];
int size[maxn],last[maxn],tot,fa[maxn];
int i,j,k,n,m,a,b,poinum;
int ra;char rx;
ll nowsum,ans;
 
 
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
void dfs(int x,ll fasum){
    for(int i=last[x];i;i=e[i].pre)if(e[i].too!=fa[x]&&size[e[i].too]<<1>poinum){
        nowsum=fasum+(ll)(poinum-size[e[i].too]*2)*e[i].dis;
        if(nowsum<ans)ans=nowsum;
        dfs(e[i].too,nowsum);
    }
}
void dfs1(int x){
    for(int i=last[x];i;i=e[i].pre)if(e[i].too!=fa[x])
        fa[e[i].too]=x,dfs1(e[i].too),size[x]+=size[e[i].too],nowsum+=(ll)size[e[i].too]*e[i].dis;
}
int main(){
    n=read();
    for(i=1;i<=n;i++)size[i]=read(),poinum+=size[i];
    for(i=1;i<n;i++){
        a=read();b=read();e[++tot].dis=e[tot+1].dis=read();
        e[tot].too=b;e[tot].pre=last[a];last[a]=tot;
        e[++tot].too=a;e[tot].pre=last[b];last[b]=tot;
    }
    dfs1(1);ans=nowsum;
    dfs(1,nowsum);
    printf("%lld
",ans);
    return 0;
}

bzoj 1592: [Usaco2008 Feb]Making the Grade 路面修整

　　显然（看题解才知道的TAT）一段路修整后，高度一定和原来那些路中的某一段相等。。。。所以把高度离散化一下就变成O(n^2)的dp了。。。

　　不下降的情况：f[i][j]表示前i段路，第i段高度修整为j的最小支出

　　　　　　　　　　f[i][j]=min{ f[i-1][k]+abs(h[i]-h[j]) }，（k<=j）转移的过程中顺便记录一下k就行了

　　不上升就倒过来做一遍

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#define uint unsigned int
#define ll long long
using namespace std;
const int maxn=2005;
ll f[maxn][maxn],mn,ans;
int a[maxn],b[maxn];
int ra;char rx;
int i,j,k,n,m,nn;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
inline short getpos(int x){
    short l=1,r=nn,mid;
    while(l<r){
        mid=(l+r+1)>>1;
        if(b[mid]<=x)l=mid;else r=mid-1;
    }return l;
}
int main(){
    n=read();for(i=1;i<=n;i++)a[i]=read();memcpy(b,a,(n+1)<<2);
    sort(b+1,b+1+n);
    nn=unique(b+1,b+1+n)-b-1;
    for(i=1;i<=n;i++)a[i]=getpos(a[i]);
    for(i=1;i<=n;i++)memset(f[i],50,(nn+1)<<3);ans=f[1][0];
    for(i=1;i<=n;i++){mn=f[i-1][0];
        for(j=1;j<a[i];j++){
            if(f[i-1][j]<mn)mn=f[i-1][j];
            f[i][j]=mn+b[a[i]]-b[j];
        }
        for(j=a[i];j<=nn;j++)mn=min(mn,f[i-1][j]),f[i][j]=mn+b[j]-b[a[i]];
    }
    for(i=1;i<=nn;i++)if(f[n][i]<ans)ans=f[n][i];
      
    for(i=1;i<=n;i++)memset(f[i],50,(nn+1)<<3);
    for(i=1;i<=n;i++){mn=f[i-1][nn];
        for(j=nn;j>a[i];j--){
            if(f[i-1][j]<mn)mn=f[i-1][j];
            f[i][j]=mn+b[j]-b[a[i]];
        }
        for(j=a[i];j;j--)mn=min(mn,f[i-1][j]),f[i][j]=mn+b[a[i]]-b[j];
    }
    for(i=1;i<=nn;i++)if(f[n][i]<ans)ans=f[n][i];
    printf("%lld
",ans);
    return 0;
}

bzoj 1725：[Usaco2006 Nov]Corn Fields牧场的安排

　　数据范围就是状压了。。

　　f[i][j]表示前i行，第i行种草状态为j的总方案数。

　　f[i][j]=sum{ f[i-1][k] }，j状态和k状态是合法的（没种到那一行贫瘠的土地，且没有草相邻），且j&k==0（没有上下两行没有草在同一列）

　　预处理了各种非法情况结果比直接枚举慢= =

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const short maxn=13;
const int modd=100000000;
short two[maxn],mapl[maxn],mx;
short map[(1<<12)+2][400];
short i,j,k,n,m,tmp,now,pre;
int f[13][(1<<12)+1],ans;
char x;
int main(){
    scanf("%d%d",&n,&m);
    mx=1<<m;two[1]=1;
    for(i=2;i<=m;i++)two[i]=two[i-1]<<1;
    for(i=0;i<mx;i++){
        bool flag=0;
        for(j=1;j<m&&!flag;j++)if(i&two[j]&&i&two[j+1])flag=1;
        if(!flag)map[0][++map[0][0]]=i;
    }
    for(i=1;i<mx;i++){
        tmp=i-(i&(-i));
        for(j=map[tmp][0];j;j--)if(!(map[tmp][j]&i))map[i][++map[i][0]]=map[tmp][j];
    }
    now=1;pre=0;
    f[0][0]=1;
    for(i=1;i<=n;i++){
        now=i;pre=i-1;
        for(j=1;j<=m;j++){for(x=getchar();x<'0'||x>'1';x=getchar());mapl[i]+=(x=='0')*two[j];}
        for(j=map[0][0],tmp=map[0][j];j;j--,tmp=map[0][j])if(!(tmp&mapl[i-1])&&f[pre][tmp])
            for(k=map[tmp][0];k;k--)if(!(map[tmp][k]&mapl[i]))
                f[now][map[tmp][k]]+=f[pre][tmp],f[now][map[tmp][k]]-=(f[now][map[tmp][k]]>=modd)?modd:0;
    }
    for(i=0;i<mx;i++)ans+=f[n][i],ans-=(ans>=modd)?modd:0;
    printf("%d
",ans);
    return 0;
}

bzoj 1711：[Usaco2007 Open]Dingin吃饭

　　二分图最大匹配。。s连奶牛，饮料和食品连t，每头牛往它要吃的东西连边。。。用dinic比匈牙利算法慢了点

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxn=103;
struct zs{
    short too,flow;
    int pre;
}e[100233];
short dis[423],dl[423];
short l,r,now;
int last[423],tot,s,t,n,m1,m2,num1,num2,a,i,j,ans;
  
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
inline void insert(short a,short b){
    e[++tot].too=b;e[tot].flow=1;e[tot].pre=last[a];last[a]=tot;
    e[++tot].too=a;e[tot].flow=0;e[tot].pre=last[b];last[b]=tot;
}
bool bfs(){
    memset(dis,255,(t+1)<<1);
    l=0;r=1;dl[1]=s;dis[s]=0;
    short now;int i;
    while(l<r){
        now=dl[++l];
        for(i=last[now];i;i=e[i].pre)if(e[i].flow&&dis[e[i].too]==-1)
            dl[++r]=e[i].too,dis[e[i].too]=dis[now]+1;
    }
    return dis[t]!=-1;
}
short dfs(short x,short mx){
    if(!mx||x==t)return mx;
    short w,used=0;int i;
    for(i=last[x];i;i=e[i].pre)if(e[i].flow&&dis[e[i].too]==dis[x]+1){
        w=dfs(e[i].too,min(mx-used,(int)e[i].flow));if(w){
            e[i].flow-=w;e[((i-1)^1)+1].flow+=w;
            used+=w;if(used==mx)return used;
        }
    }
    dis[x]=-1;return used;
}
int main(){
    n=read();m1=read();m2=read();s=0;t=n*2+m1+m2+1;
    for(i=1;i<=n;i++){
        insert(i+m1,i+m1+n);
        num1=read();num2=read();
        for(j=1;j<=num1;j++)a=read(),insert(a,i+m1);
        for(j=1;j<=num2;j++)a=read(),insert(i+m1+n,a+m1+n*2);
    }
    for(i=1;i<=m1;i++)insert(0,i);
    for(i=1;i<=m2;i++)insert(n*2+m1+i,t);
    while(bfs())ans+=dfs(s,23333);
    printf("%d
",ans);
    return 0;
}

bzoj 1668： [Usaco2006 Oct]Cow Pie Treasures 馅饼里的财富

　　裸dp。f[i][j]表示走到第i列，第j行最大财富，

　　f[1][1]=map[1][j];f[i][j]=max{f[i-1][j-1],f[i-1][j],f[i-1][j+1]}

　　注意边界。。。。第0、n+1行和第1列初始化成负无穷QAQ

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxh=102;
int map[maxh][maxh];
int i,j,k,n,m,now,pre;
int f[2][maxh];
char x;
inline void read(int &ans){
    x=getchar();int fh=1;
    while((x<'0'||x>'9')&&x!='-')x=getchar();
    if(x=='-')fh=-1,x=getchar();
    while(x>='0'&&x<='9')ans*=10,ans+=x-48,x=getchar();ans*=fh;
}
int main(){
    read(n);read(m);
    for(i=1;i<=n;i++)for(j=1;j<=m;j++)read(map[i][j]);
    f[0][1]=map[1][1];for(i=2;i<=n;i++)f[0][i]=-1023333333;
    for(i=2;i<=m;i++){
        pre=i&1;now=pre^1;f[pre][0]=f[pre][n+1]=-1023333333;
        for(j=1;j<=n;j++)f[now][j]=max(f[pre][j],max(f[pre][j-1],f[pre][j+1]))+map[j][i];
    }
    printf("%d
",f[now][n]);
    return 0;
}

bzoj 1571： [Usaco2009 Open]滑雪课Ski

　　dp，f[i][j]表示前i时间过后，能力值为j的最大滑雪次数

 　　f[i][j]=max{

　　　　f[i-1][j]，//开颓

　　　　f[ i-Dmin[j] ][ j ]+1，//先把斜坡按所需能力排序，Dmin[j]表示 所需能力值<=j的斜坡中 所需最小时长

　　　　g[ i-L[k] ]，//上第k节课（前提是有课= =），g[i]表示f[i][1..100]中的最大值

　　}

 　　代码丑得不忍直视。。。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn=10001;
struct lesson{
    short st,l,val;
}a[101];
struct poi{
    short need,cost;
}b[maxn];
short f[maxn][101],g[maxn],ans;
short cost[maxn],need[maxn],M[maxn],L[maxn],aa[101];
bool can[101];
int i,j,k,n,m,maxt,nn;
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
bool cmp(lesson a,lesson b){
    return a.st<b.st;
}
bool cmp1(poi a,poi b){
    return a.need<b.need;
}
bool cmp2(poi a,poi b){
    return a.cost<b.cost;
}
inline short getpos(int x){
    short l=1,r=nn,mid;
    while(l<r){
        mid=(l+r+1)>>1;
        if(aa[mid]<=x)l=mid;else r=mid-1;
    }
    return l;
}
int main(){
    maxt=read();n=read();m=read();
    for(i=1;i<=n;i++)a[i].st=read(),a[i].l=read(),a[i].val=aa[i]=read();
    sort(a+1,a+1+n,cmp);aa[n+1]=1;sort(aa,aa+2+n);nn=unique(aa+1,aa+2+n)-aa-1;//printf("   %d
",nn);
    for(i=1;i<=n;i++)a[i].val=getpos(a[i].val);
    for(i=1;i<=m;i++)b[i].need=read(),b[i].cost=read();
    sort(b+1,b+1+m,cmp1);int tmp=1,tmp1=b[1].cost;
    for(i=2;i<=m;i++)if(b[i].cost<tmp1)tmp1=b[i].cost,b[++tmp].cost=b[i].cost,b[tmp].need=b[i].need;
    m=tmp;
    sort(b+1,b+1+m,cmp2);
    int nowlesson=0,nowpoi=0;
    memset(f[0],150,sizeof(f[0]));f[0][1]=0;can[1]=1;
    for(i=1;i<=maxt;i++){
        memcpy(f[i],f[i-1],(nn+1)<<1);
        while(nowpoi<m&&b[nowpoi+1].cost<=i)nowpoi++;
        while(nowlesson<n&&a[nowlesson+1].st+a[nowlesson+1].l==i)nowlesson++,f[i][a[nowlesson].val]=g[a[nowlesson].st],can[a[nowlesson].val]=1;
        for(j=1;j<=nn;j++)if(can[j]){
            for(k=1;k<=nowpoi;k++)if(aa[j]>=b[k].need&&f[i-b[k].cost][j]>=f[i][j])f[i][j]=f[i-b[k].cost][j]+1;
    //      printf("%d %d    %d
",i,j,f[i][j]);
            if(f[i][j]>g[i])g[i]=f[i][j];
        }//printf("   gi:%d
",g[i]);
    }
    for(i=1;i<=nn;i++)ans=max(ans,f[maxt][i]);
    printf("%d
",ans);
    return 0;
}

bzoj 1715： [Usaco2006 Dec]Wormholes 虫洞

　　询问图中有没有负环。。。（回到过去必须是回到起点并且时间比出发时还早）

　　dfs版的spfa判负环。。

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxn=502;
const int maxm=5233;
struct zs{
    short too,pre,dis;
}e[maxm];
short i,j,k,n,m,tot,T,w,a,b;
short last[maxn];
int dis[maxn];
bool u[maxn],uu[maxn];
short ra;char rx;
inline short read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
bool dfs(short x){
    short i,j;
    uu[x]=u[x]=1;
    for(i=last[x];i;i=e[i].pre)if(dis[e[i].too]>dis[x]+e[i].dis){
        dis[e[i].too]=e[i].dis+dis[x];
        if(u[e[i].too]||dfs(e[i].too)){u[x]=0;return 1;}
    }u[x]=0;
    return 0;
}
bool spfa(){
    short j;
    for(j=1;j<=n;j++)if(!uu[j]&&dfs(j))return 1;
    return 0;
}
int main(){
    T=read();
    for(int ii=1;ii<=T;ii++){
        n=read();m=read();w=read();
        if(ii>1)memset(last,0,(n+1)<<1),memset(uu,0,n+1),tot=0;
        for(i=1;i<=m;i++){
            e[++tot+1].too=a=read();e[tot].too=b=read();e[tot].dis=e[tot+1].dis=read();
            e[tot].pre=last[a];last[a]=tot++;
            e[tot].pre=last[b];last[b]=tot;
        }
        for(i=1;i<=w;i++)a=read(),e[++tot].too=read(),e[tot].dis=-read(),e[tot].pre=last[a],last[a]=tot;
        bool flag=spfa();
        if(flag)printf("YES
");else printf("NO
");
    }
    return 0;
}

bzoj 1596： [Usaco2008 Jan]电话网络

　　树形dp。。http://www.cnblogs.com/czllgzmzl/p/5064626.html

bzoj 2442： [Usaco2011 Open]修剪草坪

　　单调队列。。

　　最大效率==总效率-最小损失效率。f[i]表示前i头奶牛，因为不能有连续K只奶牛而损失的效率的最小值（第i头牛不安排）。

　　f[i]=min{　f[j]　} +E[i]，（i-j<=K）

#include<cstdio>
#include<iostream>
#include<cstring>
#define ll long long
using namespace std;
const int maxn=100023;
int dl[maxn];
ll f[maxn],sum;
int i,j,k,n,m,l,r;
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
int main(){
    n=read();k=read()+1;
    l=r=1;dl[1]=0;
    for(i=1;i<=n+1;i++){
        while(l<r&&i-dl[l]>k)l++;
        if(i<=n)j=read();else j=0;
        f[i]=f[dl[l]]+j;sum+=j;
        while(l<=r&&f[dl[r]]>=f[i])r--;
        dl[++r]=i;
    }
    printf("%lld
",sum-f[dl[l]]);
    return 0;
}

bzoj 1233:  [Usaco2009Open]干草堆tower

　　斜率优化。。。

　　看了别人（似乎是wshjzaa？）题解才明白TAT　　http://www.cnblogs.com/sagitta/p/4650681.html

　　注：题解最后似乎有个地方<和>打反了？（或者是我语文不好。。）

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn=100003;
int f[maxn],pre[maxn],g[maxn];
int i,j,k,n,m,l,r;
int dl[maxn];
 
short ra;char rx;
inline short read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
int main(){
    scanf("%d",&n);
    for(i=1;i<=n;i++)pre[i]=read()+pre[i-1];
    l=r=1;dl[r]=n+1;
    for(i=n;i;i--){
        while(l<=r&&f[dl[l]]<=pre[dl[l]-1]-pre[i-1])l++;l--;
        f[i]=pre[dl[l]-1]-pre[i-1];
        g[i]=g[dl[l]]+1;
        while(l<=r&&pre[dl[r]-1]-f[dl[r]]<=pre[i-1]-f[i])r--;
        dl[++r]=i;
    }
    printf("%d
",g[1]);
    return 0;
}

bzoj 1707:  [Usaco2007 Nov]tanning分配防晒霜

　　贪心。。http://www.cnblogs.com/czllgzmzl/p/5064620.html

bzoj 1709： [Usaco2007 Oct]Super Paintball超级弹珠

　　难得的傻逼题。。可以O(n^3)无脑暴力。。。

　　或者是先预处理一下，读入时处理出 每一行、每一列、每一条对角线的对手数量。。。当然还有每一个点上的对手数

　　某个射击位置(x,y)能打到的对手数就是 第x行的对手数+第y行的对手数+所在两条对角线的对手数-3*（(x,y)这个点上的对手数）

#include<cstdio>
#include<iostream>
#include<cstring>
#define ll long long
using namespace std;
const int maxn=105;
int h[maxn],l[maxn],dj1[maxn<<1],dj2[maxn<<1],map[maxn][maxn];
int i,j,k,n,m,ans,a,b;
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
int main(){
    n=read();m=read();
    for(i=1;i<=m;i++)a=read(),b=read(),h[a]++,l[b]++,dj1[a+b-1]++,dj2[a-b+n]++,map[a][b]++;
    for(i=1;i<=n;i++)for(j=1;j<=n;j++)
    if(h[i]+l[j]+dj1[i+j-1]+dj2[i-j+n]-map[i][j]*3==m)ans++;
    printf("%d
",ans);
    return 0;
}

bzoj 1576： [Usaco2009 Jan]安全路经Travel

　　并查集正确姿势。。http://www.cnblogs.com/czllgzmzl/p/5064758.html

bzoj 1593： [Usaco2008 Feb]Hotel 旅馆

　　比较正常的线段树题目。。。维护一段只有0和1的区间里面，最长的0的长度，从左边开始、从右边开始的最长的0的长度

　　每次查找区间位置的时候，如果左子树里的够长就去左子树找，不然试试跨过左右子树的那段，最后才去右子树里找。（无解直接输出0）

　　区间修改的话就维护一个标记，表示当前区间被覆盖的情况（客人订满、客人退空、已下传）

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int maxn=66233;
const int inf=1023333333;
int mx[maxn<<1],l[maxn<<1],r[maxn<<1],lmx[maxn<<1],rmx[maxn<<1],size[maxn<<1],mid[maxn<<1],mxpos[maxn<<1];
short cov[maxn<<1];//0：全可用，1：全不可，2：其他或已下传 
int ra;char rx;
int i,j,k,n,m,ans,tot,L,R,id,pos;
inline void pushup(int now,int l,int r){
    lmx[now]=lmx[l];if(lmx[l]==size[l])lmx[now]+=lmx[r];
    rmx[now]=rmx[r];if(rmx[r]==size[r])rmx[now]+=rmx[l];
    mx[now]=rmx[l]+lmx[r];mxpos[now]=mid[now]-rmx[l]+1;if(mx[l]>mx[now])mx[now]=mx[l],mxpos[now]=mxpos[l];if(mx[r]>mx[now])mx[now]=mx[r],mxpos[now]=mxpos[r];
}
void build(int a,int b){
    int now=++tot;mid[now]=(a+b)>>1;
    mx[now]=lmx[now]=rmx[now]=size[now]=b-a+1;mxpos[now]=a;cov[now]=2;
    if(a<b){
        l[now]=tot+1;build(a,mid[now]);
        r[now]=tot+1;build(mid[now]+1,b);
    }
}
inline void pushdown(int now,int l,int r){
    if(cov[now]){
        lmx[l]=lmx[r]=rmx[l]=rmx[r]=mx[l]=mx[r]=mxpos[r]=mxpos[l]=0;
        cov[l]=cov[r]=1;
    }else{
        lmx[l]=rmx[l]=mx[l]=size[l];mxpos[l]=mid[now]-size[l]+1;
        lmx[r]=rmx[r]=mx[r]=size[r];mxpos[r]=mid[now]+1;
        cov[l]=cov[r]=0;
    }
    cov[now]=2;
}
void update(int now,int a,int b,int c,int d,int col){
    if(c<=a&&d>=b){
        cov[now]=col;
        if(col)lmx[now]=rmx[now]=mx[now]=mxpos[now]=0;
        else lmx[now]=rmx[now]=mx[now]=size[now],mxpos[now]=a;
        return;
    }
    if(cov[now]!=2)pushdown(now,l[now],r[now]);
    if(c<=mid[now])update(l[now],a,mid[now],c,d,col);
    if(d>mid[now])update(r[now],mid[now]+1,b,c,d,col);
    pushup(now,l[now],r[now]);
}
int getpos(int now,int a,int b,int len){
    int L=l[now],R=r[now];
    if(cov[now]!=2)pushdown(now,L,R);
    if(mx[L]>=len)return getpos(L,a,mid[now],len);
    else if(rmx[L]+lmx[R]>=len)return mid[now]-rmx[L]+1;
    else return getpos(R,mid[now]+1,b,len);
}
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
int main(){
    n=read();m=read();
    build(1,n);
    for(i=1;i<=m;i++){
        id=read();L=read();
        if(id==1){
            if(mx[1]>=L){
                pos=getpos(1,1,n,L);
                printf("%d
",pos);
                update(1,1,n,pos,pos+L-1,1);
            }else printf("0
");
        }else{
            R=read();
            update(1,1,n,L,L+R-1,0);
        }
    }
    return 0;
}

　　1A感人TAT

bzoj 1697： [Usaco2007 Feb]Cow Sorting牛排序

　　置换群。。现在还是不会置换群QAQ。。。不过至少这题的题解看得懂QAQ。。。

　　题解网上一坨。。因为poj里也有= =

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
const int maxn=10023;
struct zs{
    short pos;
    int val;
}a[maxn];
short i,j,pos,n;
ll mn,ans,nowmn,nowsum,len;
bool u[maxn];
 
bool cmp(zs a,zs b){
    return a.val<b.val;
}
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
int main(){
    n=read();
    for(i=1;i<=n;i++)a[i].val=read(),a[i].pos=i;
    sort(a+1,a+1+n,cmp);mn=a[1].val;
    for(i=1;i<=n;i++)if(!u[i]){
        u[i]=1;nowmn=nowsum=a[i].val;len=1;
        for(pos=a[i].pos;!u[pos];pos=a[pos].pos){
            len++,nowsum+=(ll)a[pos].val,u[pos]=1;
            if(a[pos].val<nowmn)nowmn=a[pos].val;
        }
        ans+=nowsum+min((len-2)*nowmn,nowmn+(len+1)*mn);
    }
    printf("%lld
",ans);
    return 0;
}

bzoj 1828： [Usaco2010 Mar]balloc 农场分配

　　把各个请求按右端点从小到大排序。。然后直接依次能满足的就满足。。。这样就行了。。。。至于为什么这样子贪心是对的。。TAT

　　设区间左右端点为l[],r[]...

　　因为是按r排序的：如果当前区间插入后会影响到后面的某个区间的话，那么相比于那个被影响的区间，插入当前区间更优。

　　　　　　　　　　 并且在插入当前区间前我们已经尽量满足了r更小的区间，所以当前区间对之前的区间无影响。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=132333;
struct zs{
    int l,r;
}a[maxn];
int mn[maxn<<1],l[maxn<<1],r[maxn<<1],mid[maxn<<1],tag[maxn<<1];
int ra;char rx;
int i,j,k,n,m,ans,tot;
  
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
void build(int a,int b){
    int now=++tot;
    mid[now]=(a+b)>>1;
    if(a<b){
        l[now]=tot+1;build(a,mid[now]);
        r[now]=tot+1;build(mid[now]+1,b);
        if(mn[l[now]]<mn[r[now]])mn[now]=mn[l[now]];else mn[now]=mn[r[now]];
    }else mn[now]=read();
}
bool cmp(zs a,zs b){
    return a.r<b.r;
}
inline void pushdown(int now,int t){
    tag[l[now]]+=t;tag[r[now]]+=t;
    mn[l[now]]-=t;mn[r[now]]-=t;
    tag[now]=0;
}
int query(int now,int a,int b,int c,int d){
    if(c<=a&&d>=b)return mn[now];
    if(tag[now])pushdown(now,tag[now]);
    if(d<=mid[now])return query(l[now],a,mid[now],c,d);
    else if(c>mid[now])return query(r[now],mid[now]+1,b,c,d);
    else return min(query(l[now],a,mid[now],c,d),query(r[now],mid[now]+1,b,c,d));
}
void insert(int now,int a,int b,int c,int d){
    if(c<=a&&d>=b){tag[now]++;mn[now]--;return;}
    if(tag[now])pushdown(now,tag[now]);
    if(c<=mid[now])insert(l[now],a,mid[now],c,d);
    if(d>mid[now])insert(r[now],mid[now]+1,b,c,d);
    mn[now]=min(mn[l[now]],mn[r[now]]);
}
int main(){
    n=read();m=read();
    build(1,n);
    for(i=1;i<=m;i++)a[i].l=read(),a[i].r=read();
    sort(a+1,a+1+m,cmp);
    for(i=1;i<=m;i++)if(query(1,1,n,a[i].l,a[i].r)>0)ans++,insert(1,1,n,a[i].l,a[i].r);
    printf("%d
",ans);
    return 0;
}

bzoj 1589： [Usaco2008 Dec]Trick or Treat on the Farm 采集糖果

　　就是求后继节点的总数。。。因为整张图是由若干个基环内向树组成，所以可以用tarjan缩点后做。。。

　　不过因为是基环内向树（同今年noipD1T2）。。从某个点开始一直走就会把它所连向的环走遍，也就起到了缩点的效果。。

　　具体就开个栈记录一下当前路径，记录一个点是否在栈中。注意已经求出后继节点数的点就不用再走了.

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn=100001;
int to[maxn],ans[maxn],st[maxn];
bool ins[maxn];
int i,j,n,m,top,ed,len,tmp;
char s[6];
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
inline void outx(int x){
    for(tmp=0;x;x/=10)s[tmp++]=x%10;
    for(register int i=tmp-1;i>=0;i--)putchar(s[i]+48);putchar('
');
}
int main(){
    n=read();
    for(i=1;i<=n;i++)to[i]=read();
    for(i=1;i<=n;i++)if(!ans[i]){
        ins[i]=ans[i]=1;st[top=1]=i;
        for(j=to[i];!ans[j]&&!ins[j];j=to[j])st[++top]=j,ins[j]=1;
        if(ins[j]){
            for(ed=j,j=top,len=1;st[j]!=ed;j--)len++;
            for(;top>=j;top--)ans[st[top]]=len,ins[st[top]]=0;
        }
        while(top)ans[st[top]]=1+ans[to[st[top]]],ins[st[top--]]=0;
    }
    for(i=1;i<=n;i++)outx(ans[i]);
    return 0;
}

//之前弄了半天依然被踩在#2。。。。知道刚刚才想到一个布尔数组不用开才弄到200ms。。。再加了个输出优化瞬间就176ms了= =感人肺腑

　　

//为什么我每次用register int都更慢

bzoj 1754： [Usaco2005 qua]Bull Math

　　高精度乘法。。。。。。。。。。

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int modd=10000;
int a[23],b[23],ans[23],len;
char s[44];
short i,j;
int main(){
    scanf("%s",s);a[0]=1;
    for(i=strlen(s),len=1;i;i--){
        a[a[0]]+=(s[i-1]-'0')*len;
        len*=10;if(len>=modd&&i>1)len=1,a[0]++;
    }
    scanf("%s",s);b[0]=1;
    for(i=strlen(s),len=1;i;i--){
        b[b[0]]+=(s[i-1]-'0')*len;
        len*=10;if(len>=modd&&i>1)len=1,b[0]++;
    }
    len=a[0]+b[0];
    for(i=1;i<=a[0];i++)for(j=1;j<=b[0];j++){
        ans[i+j-1]+=a[i]*b[j];
        if(ans[i+j-1]>=modd)ans[i+j]+=ans[i+j-1]/modd,ans[i+j-1]%=modd;
    }
    while(!ans[len]&&len>1)len--;
    printf("%d",ans[len]);
    for(i=len-1;i;i--){
        for(j=10;j<modd;j*=10)if(ans[i]<j)putchar('0');
        printf("%d",ans[i]);
    }printf("
");
    return 0;
}

bzoj 1770： [Usaco2009 Nov]lights 燈

　　高斯消元解异或方程组。。。。自由元就暴力枚举+最优性剪枝= =。。。

　　话说自由元啊什么的一直不懂。。。数学方面以后再慢慢补吧（已经无数次这么说了TAT

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
short f[40][40],ans[40];
int i,j,k,n,m,mn,a,b;
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
void gauss(){
    short i,j,k;
    for(i=1;i<=n;i++){
        for(j=i;j<=n&&!f[j][i];j++);if(j>n)continue;
        if(i!=j)for(k=1;k<=n+1;k++)swap(f[i][k],f[j][k]);
        for(j=1;j<=n;j++)if(i!=j&&f[j][i])
            for(k=1;k<=n+1;k++)f[j][k]^=f[i][k];
    }
}
void dfs(short now,int tot){
    if(tot>=mn)return;
    if(!now){
        mn=tot;return;
    }
    if(f[now][now]){
        short i;
        ans[now]=f[now][n+1];
        for(i=now+1;i<=n;i++)if(f[now][i])ans[now]^=ans[i];
        dfs(now-1,tot+ans[now]);
    }else{
        ans[now]=0;dfs(now-1,tot);
        ans[now]=1;dfs(now-1,tot+1);
    }
}
int main(){
    n=read();m=read();
    for(i=1;i<=n;i++)f[i][i]=f[i][n+1]=1;
    for(i=1;i<=m;i++)a=read(),b=read(),f[a][b]=f[b][a]=1;
    gauss();
    mn=1022223333;
    dfs(n,0);
    printf("%d
",mn);
    return 0;
}

　　抄了黄学长代码。。捂脸

bzoj 1691： [Usaco2007 Dec]挑剔的美食家

　　有点像bzoj1828。。。都是两个限定条件，虽然具体有点不同= =

　　把奶牛按要求最低价升序排序，牧草按价格升序排序。

　　枚举牧草，每种牧草让可接受它的奶牛中，对新鲜度要求最高的奶牛吃。

　　具体就是用平衡树维护可接受当前价格的奶牛（会越来越多）的要求新鲜度。。每种牧草按新鲜度在树中找一下前驱。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#define ll long long
using namespace std;
const int maxn=100233;
const int inf=1002333333;
struct gc{
    int c,v;
}g[maxn],c[maxn];
 
int t[maxn],l[maxn],r[maxn],rnd[maxn],sz[maxn];
int i,j,k,n,m,tot,rt,num;
ll ans;
 
inline void lturn(int &x){
    int R=r[x];r[x]=l[R];l[R]=x;x=R;
}
inline void rturn(int &x){
    int L=l[x];l[x]=r[L];r[L]=x;x=L;
}
void insert(int &x,int val){
    if(!x){x=++tot;t[x]=val;rnd[x]=rand();sz[x]=1;//printf("! cow v:%d  in
",val);
            return;
    }
    if(val==t[x])sz[x]++;
     else if(val<t[x])
         {insert(l[x],val);
          if(rnd[l[x]]<rnd[x])rturn(x);
    }else{insert(r[x],val);
          if(rnd[r[x]]<rnd[x])lturn(x);
    }
}
void del(int &x,int val){
    if(t[x]==val){
        //printf("!  deleting %d   v:%d
",x,t[x]);
        if(sz[x]>1)sz[x]--;
        else if(!(l[x]&&r[x]))x=l[x]+r[x];//,printf("---->%d
",x);
        else if(rnd[l[x]]<rnd[r[x]]){rturn(x);del(x,val);}else {lturn(x);del(x,val);}
    }else if(val<t[x])del(l[x],val);else del(r[x],val);
}
int find(int x,int val){if(!x)return 0;
    if(t[x]>val)return find(l[x],val);else{
        int tmp=find(r[x],val);
        if(tmp)return tmp;else return t[x];
    }
}
inline void read(int &ans){
    char x=getchar();
    while(x<'0'||x>'9')x=getchar();
    while(x>='0'&&x<='9')ans*=10,ans+=x-48,x=getchar();
}
bool cmp(gc a,gc b){return a.c<b.c;}
int main(){
    read(n);read(m);
    if(m<n){printf("-1
");return 0;};
    for(i=1;i<=n;i++)read(c[i].c),read(c[i].v);
    for(i=1;i<=m;i++)read(g[i].c),read(g[i].v);
    sort(c+1,c+1+n,cmp);sort(g+1,g+1+m,cmp);j=rt=0;
    for(i=1;i<=m&&m-i+1>=n-num&&num<n;i++){
        while(j<n&&c[j+1].c<=g[i].c)j++,insert(rt,c[j].v);
        int val=find(rt,g[i].v);
        //printf("grass%d(%d %d)  be eaten by cow v:%d(%d %d)
",i,g[i].c,g[i].v,val,,c[pos].v);
        if(val)
            num++,ans+=(ll)g[i].c,del(rt,val);
                                //,printf("%d(%d %d) eats  %d(%d %d)
",pos,c[pos].c,c[pos].v,i,g[i].c,g[i].v);
    }
    if(num==n)
    printf("%lld
",ans);else printf("-1
");
    return 0;
}

　　手打treap比调stl的慢= =

bzoj 1753： [Usaco2005 qua]Who's in the Middle

　　如题。。。。。。。。。。。。。。。。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=10001;
int a[maxn],n,i;
 
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
int main(){
    n=read();for(i=1;i<=n;i++)a[i]=read();
    sort(a+1,a+1+n);
    printf("%d
",a[(n+1)>>1]);
    return 0;
}

加了快速读入比没加的慢是什么情况= =

bzoj 1574： [Usaco2009 Jan]地震损坏Damage

　　就是说对于报告的每个点，都要找到一圈点把它围起来（与1点阻断）。。显然（又是看题解才知道的QAQ）这一圈点就是那个点相邻的所有点（当然相邻点也可能是被报告的点，但总之这些点都无法到达了）。。

　　因为圈内的点都无法到达，我们要使得圈上及圈内的点最少。。所以圈越小越好。。

　　把每个报告的点的相邻节点都设为不可通过，最后统计下还能到达的点的数目就好。

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
struct zs{
    short too;
    int pre;
}e[200233];
int last[30233],dl[30023];
bool dead[30233];
int i,j,k,n,m,a,b,p,l,r,now,tot;
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
inline void insert(short a,short b){
    e[++tot].too=b;e[tot].pre=last[a];last[a]=tot;
    e[++tot].too=a;e[tot].pre=last[b];last[b]=tot;
}
int main(){
    n=read();m=read();p=read();
    for(i=1;i<=m;i++)a=read(),b=read(),insert(a,b);
    for(i=1;i<=p;i++){
        a=read();dead[a]=1;
        for(j=last[a];j;j=e[j].pre)dead[e[j].too]=1;
    }
    l=0;if(!dead[1])r=1;dl[1]=1;dead[1]=1;
    while(l<r){
        now=dl[++l];
        for(i=last[now];i;i=e[i].pre)if(!dead[e[i].too])dead[e[i].too]=1,dl[++r]=e[i].too;
    }
    printf("%d
",n-r);
    return 0;
}

bzoj 1584： [Usaco2009 Mar]Cleaning Up 打扫卫生

　　DPhttp://www.cnblogs.com/czllgzmzl/p/5066443.html

bzoj 1710： [Usaco2007 Open]Cheappal 廉价回文

　　因为最后要形成回文串。。。对于回文串来说删一个字母和 在对应位置添加一个同样的字母是等价的= =

　　所以把一个字母和谐掉的代价是min(删除该字母费用，添加该字母费用)。。（记为cost[]）

　　接下来就是区间dp了。。。f[i][j]表示把原字符串中第i个~第j个字母变成回文串的最小代价。。原字符串为s

　　f[i][j]=min{

　　　　f[i][j-1]+cost[s[j]]，f[i+1][j]+cost[s[i]]，

　　　　f[i+1][j-1]，（s[i]==s[j]）

　　}最后答案就是f[1][m]

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxn=2033;
char s[maxn],c[27];
short cost[233],tmp;
int f[maxn][maxn];
short i,j,k,n,m,len;
short ra;char rx,trx;
inline short read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
int main(){
    n=read();m=read();
    for(s[1]=getchar();s[1]<'a'||s[1]>'z';s[1]=getchar());
    for(i=2;i<=m;i++)s[i]=getchar();
    for(i=1;i<=n;i++){
        for(trx=getchar();trx<'a'||trx>'z';trx=getchar());
        tmp=read();cost[trx]=read();
        if(tmp<cost[trx])cost[trx]=tmp;
    }
    for(len=2;len<=m;len++)for(i=m-len+1,j=m;i;i--,j--)
        if(s[i]==s[j])f[i][j]=f[i+1][j-1];
        else if(cost[s[j]]+f[i][j-1]<cost[s[i]]+f[i+1][j])f[i][j]=cost[s[j]]+f[i][j-1];
        else f[i][j]=cost[s[i]]+f[i+1][j];
    printf("%d
",f[1][m]);
    return 0;
}

bzoj 1703： [Usaco2007 Mar]Ranking the Cows 奶牛排名

　　善用stl。。。善调bitset。。。

　　按给出的大小关系建图。。求出每头牛i能确定的比它小的奶牛的数量num[i]，答案就是 总对数-已知的关系对数。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<bitset>
using namespace std;
short too[1008][1008];
bool u[1008],map[1008][1008];
bitset<1008>a[1008];
int i,j,k,n,m;
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
void dfs(int x){
    u[x]=1;
    for(short i=too[x][0];i;i--)if(!u[too[x][i]])dfs(too[x][i]),a[x]|=a[too[x][i]];
    else a[x]|=a[too[x][i]];
}
int main(){
    n=read();m=read();
    for(i=1;i<=m;i++){
        j=read(),k=read();
        if(!map[j][k])map[j][k]=1,too[j][++too[j][0]]=k;
    }
    for(i=1;i<=n;i++)a[i][i]=1;
    for(i=1;i<=n;i++)if(!u[i])dfs(i);
    for(j=(n-1)*n/2+n,i=1;i<=n;i++)j-=a[i].count();
    printf("%d
",j);
    return 0;
}

为啥同样是调bitset我就慢了这么多TAT

bzoj 1578： [Usaco2009 Feb]Stock Market 股票市场

　　看了老司机的题解。。。http://www.cnblogs.com/JSZX11556/p/4664348.html

　　引用：“我们假设每天买完第二天就卖掉( 不卖出也可以看作是卖出后再买入 ), 这样就是变成了一个完全背包问题了, 股票价格为体积, 第二天的股票价格 - 今天股票价格为价值.... 然后就一天一天dp...”。

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxt=500012;
int map[11][51],val,cost;
int f[maxt];
int i,j,k,n,m,T,nowt;
 
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
int main(){
    n=read();T=read();m=read();
    for(i=0;i<n;i++)for(j=0;j<T;j++)map[j][i]=read();
    for(nowt=1;nowt<T;nowt++){
        if(nowt>1)memset(f,0,(m+1)<<2);
        for(i=0;i<n;i++){
            val=map[nowt][i]-map[nowt-1][i];cost=map[nowt-1][i];
            if(val<=0)continue;
            for(j=cost;j<=m;j++)if(f[j-cost]+val>f[j])f[j]=f[j-cost]+val;
        }
        m+=f[m];
    }
    printf("%d
",m);
    return 0;
}

bzoj 1598: [Usaco2008 Mar]牛跑步

　　求第k短路。。看了kpm大爷的代码才知道可以懒出新境界。。。

　　用优先队列维护spfa的队列（其实就变成了堆优化的dij）。。一个点出队k次时我们就得出了k短路。。。。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
const int maxn=1002;
struct zs{
    int dis,pos;
};
struct edge{
    int too,pre,dis;
}e[10023];
int dis[maxn],last[maxn],sumk[maxn];
int i,j,k,n,m,size,K,a;
priority_queue<zs>q;
bool operator <(zs a,zs b){
    return a.dis>b.dis;
}
 
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
int main(){
    n=read();m=read();K=read();
    for(i=1;i<=m;i++){
        a=read();e[i].too=read();e[i].dis=read();
        e[i].pre=last[a];last[a]=i;
    }zs tmp;
    size=1;tmp.pos=n;tmp.dis=0;q.push(tmp);
    while(size&&sumk[1]<K){
        i=q.top().pos;j=q.top().dis;size--;q.pop();
        if(sumk[i]>=K)continue;
        sumk[i]++;if(i==1){printf("%d
",j);}
        for(i=last[i];i;i=e[i].pre)tmp.pos=e[i].too,tmp.dis=j+e[i].dis,q.push(tmp),size++;
    }
    for(i=K-sumk[1];i;i--)puts("-1
");
    return 0;
}

bzoj 2060: [Usaco2010 Nov]Visiting Cows 拜访奶牛

　　终于是傻逼题了。。。没有上司的舞会。树形dp，f[i][0]表示以i为根节点，i不选，能选的最多点数，f[i][1]表示以i为根节点，i选，能选的最多点数。

　　f[i][0]=sum{　max(f[j][0],f[j][1])　}，（j是i的儿子）；f[i][1]=sum{　f[j][0]　}，（j是i的儿子）

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxn=50023;
struct zs{
    int too,pre;
}e[maxn<<1];
int last[maxn],f[maxn][2];
int i,j,n,m,tot,a,b;
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
void dfs(int x,int fa){
    f[x][1]=1;
    for(int i=last[x];i;i=e[i].pre)if(e[i].too!=fa){
        dfs(e[i].too,x);
        if(f[e[i].too][0]>f[e[i].too][1])f[x][0]+=f[e[i].too][0];else f[x][0]+=f[e[i].too][1];
        f[x][1]+=f[e[i].too][0];
    }
}
int main(){
    n=read();
    for(i=1;i<n;i++){
        a=read();b=read();e[++tot].too=b;e[tot].pre=last[a];last[a]=tot;
        e[++tot].too=a;e[tot].pre=last[b];last[b]=tot;
    }
    dfs(1,0);
    printf("%d
",max(f[1][0],f[1][1]));
    return 0;
}

bzoj 1702: [Usaco2007 Mar]Gold Balanced Lineup 平衡的队列

　　和bzoj4236那题思路一样。。。求得各种颜色数的前缀和，并差分。。如果两不同位置上差分后的结果相等，就说明这两个位置之间各种颜色数量相等。

　　可以上hash。。。然而卡常无力被稳稳地踩了TAT

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=100003;
struct zs{
    int pos;
    unsigned int v;
}a[maxn];
int nownum[31],two[31];
bool u[maxn];
int i,j,k,n,m,kk,x,ans;
bool same;
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
bool cmp(zs a,zs b){
    return a.v<b.v||(a.v==b.v&&a.pos<b.pos);
}
int main(){
    n=read();k=read();two[1]=1;
    for(i=1;i<k;i++)two[i+1]=two[i]<<1;
    for(i=1;i<=n;i++){
        x=read();
        for(j=1;j<=k;j++)if(x&two[j])nownum[j]++;
        for(j=1;j<k;j++)//a[i].num[j]=nownum[j]-nownum[j+1],
            a[i].v*=233,a[i].v+=nownum[j]-nownum[j+1];
        a[i].pos=i;
    }
    n++;
    sort(a+1,a+1+n,cmp);
    for(i=1;i<=n;){
        for(j=i+1;j<=n&&a[i].v==a[j].v;j++);
        j--;
        if(a[j].pos-a[i].pos>ans)ans=a[j].pos-a[i].pos;
        i=j+1;
    }
    printf("%d
",ans);
    return 0;
}

bzoj 1704： [Usaco2007 Mar]Face The Right Way 自动转身机

　　如果K已经确定的话，可以O(n)求出最小判断次数M：从前往后扫一遍，如果一个点i上奶牛朝后站着，就把i~i+k-1头奶牛都转过来。因为此时不转的话以后就转不了了。。。

　　注意无解的判定。。。如果第i头奶牛朝后站着且i+k>n（就是没有k头奶牛可以转了）就无解。。。

　　区间修改，单点查询。。。这个可以用差分。。因为只有朝前和朝后两种，就直接异或一下就好了。时间复杂度O(n*k)

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxn=5005;
bool now[maxn],nowsum;
int i,j,k,n,m,nowans,ans;
bool mp[maxn];
char rx;
int main(){
    scanf("%d",&n);
    for(i=1;i<=n;i++){
        for(rx=getchar();rx!='F'&&rx!='B';rx=getchar());
        mp[i]^=(rx=='B');
        if(rx=='B')mp[i+1]^=1,ans++;
    }
    k=1;
    for(i=2;i<=n;i++){
        memcpy(now,mp,(n+1));nowans=nowsum=0;
        for(j=1;j<=n&&nowans<ans;j++){
            nowsum^=now[j];
            if(nowsum&&j+i>n+1){nowans=102333333;break;}
            if(nowsum)nowsum^=1,now[j+i]^=1,nowans++;
        }
        if(nowans<ans)ans=nowans,k=i;
    }
    printf("%d %d
",k,ans);
    return 0;
}

bzoj 1776： [Usaco2010 Hol]cowpol 奶牛政坛

　　由题解可得（TAT）结论：某政党内部的最长路径一定有一个端点是政党内最深的一个点。。毕竟树的直径也有一个端点在叶子节点上？

　　先一遍dfs求出每个政党最深的点，然后求它和所在政党其他点的距离的最大值。。树上两点间的距离dis(i,j)=depth[i]+depth[j]-depth[lca(i,j)]*2。。

　　总时间复杂度O(nlogn)...求lca部分试了倍增和链剖两种。。。。代码长度差不多但是倍增慢多了QAQ

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxn=200233;
const int maxdep=20;
struct zs{
    int too,pre;
}e[maxn<<1],map[maxn];
int last[maxn],dep[maxn],last1[maxn],mxpos[maxn],mxdep[maxn],bel[maxn],belong[maxn],size[maxn],fa[maxn];
int i,j,k,n,m,tot1,a,tot,K,b,ans,rt;
  
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
inline void insert(int a,int b){
    map[++tot1].too=b;map[tot1].pre=last1[a];last1[a]=tot1;
}
void dfs(int x,int pre){
    int i;size[x]=1;dep[x]=dep[pre]+1;fa[x]=pre;
    if(dep[x]>mxdep[bel[x]])mxdep[bel[x]]=dep[x],mxpos[bel[x]]=x;
    insert(bel[x],x);
    for(i=last[x];i;i=e[i].pre)if(e[i].too!=pre)
        dfs(e[i].too,x),size[x]+=size[e[i].too];
}
void dfs2(int x,int chain){
    int i,k=0;belong[x]=chain;
    for(i=last[x];i;i=e[i].pre)if(e[i].too!=fa[x]&&size[e[i].too]>size[k])k=e[i].too;
    if(!k)return;
    dfs2(k,chain);
    for(i=last[x];i;i=e[i].pre)if(e[i].too!=fa[x]&&e[i].too!=k)dfs2(e[i].too,e[i].too);
}
inline int getlcadep(int a,int b){
    for(;belong[a]!=belong[b];a=fa[belong[a]])if(dep[belong[a]]<dep[belong[b]])swap(a,b);
    if(dep[a]<dep[b])return dep[a];else return dep[b];
}
int main(){
    n=read();K=read();
    for(i=1;i<=n;i++){
        bel[i]=read();a=read();if(!a){rt=i;continue;}
        e[++tot].too=i;e[tot].pre=last[a];last[a]=tot;
        e[++tot].too=a;e[tot].pre=last[i];last[i]=tot;
    }rt=n<4?n>>1:n>>2;
    dfs(rt,0);dfs2(rt,rt);
    for(i=1;i<=K;i++){
        ans=0;
        for(k=mxpos[i],j=last1[i];j;j=map[j].pre)ans=max(ans,dep[k]+dep[map[j].too]-(getlcadep(k,map[j].too)<<1));
        printf("%d
",ans);
    }
    return 0;
}
//链剖

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxn=200233;
const int maxdep=20;
struct zs{
    int too,pre;
}e[maxn<<1],map[maxn];
int last[maxn],depth[maxn],fa[maxn][maxdep],dep[maxn],last1[maxn],mxpos[maxn],mxdep[maxn],bel[maxn];
int i,j,k,n,m,tot1,a,tot,K,b,ans,rt;
  
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
inline void insert(int a,int b){
    map[++tot1].too=b;map[tot1].pre=last1[a];last1[a]=tot1;
}
void dfs(int x,int pre){
    int i;
    dep[x]=dep[pre]+1;depth[x]=depth[pre];
    if((dep[x]&(-dep[x]))==dep[x])depth[x]++;
    if(dep[x]>mxdep[bel[x]])mxdep[bel[x]]=dep[x],mxpos[bel[x]]=x;
    insert(bel[x],x);//printf("%d %d  %d %d
",x,bel[x],dep[x],depth[x]);
      
    for(i=1;i<=depth[x];i++)fa[x][i]=fa[fa[x][i-1]][i-1];
    for(i=last[x];i;i=e[i].pre)if(e[i].too!=pre)
        fa[e[i].too][0]=x,dfs(e[i].too,x);
}
inline int getlca(int a,int b){
    int i;
    if(dep[a]<dep[b])swap(a,b);
    for(i=depth[a];i>=0;i--)if(dep[fa[a][i]]>=dep[b])a=fa[a][i];
    if(a!=b){
        for(i=depth[a];i>=0;i--)if(fa[a][i]!=fa[b][i])a=fa[a][i],b=fa[b][i];
        a=fa[a][0];
    }
    return a;
}
int main(){
    n=read();K=read();
    for(i=1;i<=n;i++){
        bel[i]=read();a=read();if(!a){rt=i;continue;}
        e[++tot].too=b=i;e[tot].pre=last[a];last[a]=tot;
        e[++tot].too=a;e[tot].pre=last[b];last[b]=tot;
    }depth[0]=-1;
    dfs(rt,0);
    for(i=1;i<=K;i++){
        ans=0;
        for(k=mxpos[i],j=last1[i];j;j=map[j].pre)ans=max(ans,dep[k]+dep[map[j].too]-(dep[getlca(k,map[j].too)]<<1));
        printf("%d
",ans);
    }
    return 0;
}
//倍增

bzoj 1700： [Usaco2007 Jan]Problem Solving 解题

　　DP。。http://www.cnblogs.com/czllgzmzl/p/5068024.html

bzoj 1734： [Usaco2005 feb]Aggressive cows 愤怒的牛

　　傻逼题。。二分答案+判定。。。。每次二分出一个答案mid后，贪心的划分，看一下能不能划出C段

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=100001;
int a[maxn];
int i,num,n,m,l,r,mid,pre;
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
int main(){
    n=read();m=read();
    for(i=1;i<=n;i++)a[i]=read();
    sort(a+1,a+1+n);
    if(m==2){printf("%d
",a[n]-a[1]);return 0;}
    if(m==n){
        for(l=a[n]-a[1],i=1;i<n;i++)if(a[i+1]-a[i]<l)l=a[i+1]-a[i];
        printf("%d
",l);return 0;
    }
    l=1;r=(a[n]-a[1])/(m-1);
    while(l<r){
        mid=(l+r+1)>>1;num=1;pre=a[1];
        for(i=2;i<=n;i++)if(a[i]-pre>=mid)pre=a[i],num++;
        if(num>=m)l=mid;else r=mid-1;
    }
    printf("%d
",l);
    return 0;
}

bzoj 1741： [Usaco2005 nov]Asteroids 穿越小行星群

　　二分图最大匹配。。。存在小行星(i,j),连一条i到j+n的边。

　　dinic比匈牙利还是略慢。。

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
const int maxn=505;
struct zs{
    int too,pre;
    bool flow;
}e[23333];
int last[maxn<<1],u[maxn<<1],dl[maxn<<1];
short dis[maxn<<1];
int i,j,k,n,m,tot,s,t,a,b,ans;
int ra;char rx;
inline int read(){
    rx=getchar();ra=0;
    while(rx<'0'||rx>'9')rx=getchar();
    while(rx>='0'&&rx<='9')ra*=10,ra+=rx-48,rx=getchar();return ra;
}
inline void insert(int a,int b){
    e[++tot].too=b;e[tot].flow=1;e[tot].pre=last[a];last[a]=tot;
    e[++tot].too=a;e[tot].flow=0;e[tot].pre=last[b];last[b]=tot;
}
inline bool bfs(){
    memset(dis,255,(t+1)<<1);
    int l=0,r=1,now,i;dl[1]=s;dis[s]=0;
    while(l<r){
        now=dl[++l];
        for(i=last[now];i;i=e[i].pre)if(dis[e[i].too]==-1&&e[i].flow)
            dis[e[i].too]=dis[now]+1,dl[++r]=e[i].too;
    }
    return dis[t]!=-1;
}
int dfs(int x,int mx){
    if(x==t)return mx;
    int i,used=0,w;
    for(i=last[x];i;i=e[i].pre)if(e[i].flow&&dis[e[i].too]==dis[x]+1){
        w=dfs(e[i].too,1);if(w){
            e[i].flow=0;;e[i^1].flow=1;
            used++;if(used==mx)return mx;
        }
    }
    dis[x]=-1;return used;
}
int main(){tot=1;
    n=read();m=read();s=0;t=n+n+1;
    for(i=1;i<=n;i++)insert(s,i),insert(i+n,t);
    for(i=1;i<=m;i++)
        a=read(),b=read(),insert(a,b+n);
    while(bfs())ans+=dfs(s,233333333);
    printf("%d
",ans);
    return 0;
}

bzoj 1705： [Usaco2007 Nov]Telephone Wire 架设电话线

　　DPhttp://www.cnblogs.com/czllgzmzl/p/5068259.html

bzoj 1783： [Usaco2010 Jan]Taking Turns

　　有点算博弈相关？http://www.cnblogs.com/czllgzmzl/p/5069730.html