usaco训练总结1

这里把最近在usaco所刷到的好题总结一下。。。

*4.2.1 草地排水“
裸的最大流（好像不满足好题的标准。。。*

#include<iostream>
#include<algorithm>
#include<string.h>
#include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
struct bian
{
    int to,cap,rev;
};
vector<bian> tu[1050];
bool vis[1050];
void add(int f,int to,int cap)
{
    tu[f].push_back((bian){to,cap,tu[to].size()});
    tu[to].push_back((bian){f,0,tu[f].size()-1});
}
int dfs(int v,int t,int f)
{
    if(v==t)
        return f;
    vis[v]=1;
    for(int i=0;i<tu[v].size();i++)
    {
        bian &e=tu[v][i];
        if(!vis[e.to]&&e.cap>0)
        {
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0)
            {
                e.cap-=d;
                tu[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
int maxflow(int s,int t)
{
    int flow=0;
    while(1)
    {
        memset(vis,0,sizeof(vis));
        int f=dfs(s,t,0x3f3f3f);
        if(f==0)
        return flow;
        flow+=f;
            }
}
int T,n,m,x,y,r;
void init()
{
    for(int i=1;i<=n;i++)
        tu[i].clear();
    memset(vis,0,sizeof(vis));
}
int main()
{

        scanf("%d%d",&m,&n);
        init();
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&x,&y,&r);
            add(x,y,r);
        }
        cout<<maxflow(1,n)<<endl;
}

usaco 4.2.2

二分图匹配，裸的最大流（好像又不满足好题。。。不粘了

usaco4.2.3

题还不错，我的做法是先二分第一个，然后得到第一个的解后，再对第二个二分贪心

sort(a+1,a+m1+1,cmp);
    sort(b+1,b+m2+1,cmp);
    int l=1,r=200000;
    while(l<r-1)
    {
        int mid=(l+r)/2;
        int num=0;
        for(int i=1;i<=m1&&a[i]<=mid;i++)
            num+=mid/a[i];
        if(num>=n)
            r=mid;
        else
            l=mid+1;
    }
    for(int i=1;i<=m1&&a[i]<=l;i++)
        num+=l/a[i];    
    if(num>=n)
        ans1=l;
    else
        ans1=r;
    cout<<ans1<<endl;
    num=0;
    int lastnum=0;
    for(int i=1;i<=ans1;i++)
    {
        for(int j=1;j<=m1&&a[j]<=i;j++)
            num+=i/a[j];
        num=min(num,n);
        chu[i]=num-lastnum;
        lastnum=num;
        num=0;
    }
    for(int i=1;i<=ans1;i++)
    {
        if(chu[i])
            for(int j=1;j<=chu[i];j++)
                next[++cnt]=i;
    }
    l=ans1,r=400000;
    bool flag=0;
    while(l<r-1)
    {
        int mid=(l+r)/2;
        memset(hj,0,sizeof(hj));
        cout<<mid<<endl;
        for(int i=1;i<=n;i++)
        {
            int kl=next[i]-next[i-1];
            for(int j=1;j<=m2;j++)
            {
                if(hj[j])
                    hj[j]=max(hj[j]-kl,0);
            }
            flag=0;
            for(int j=m2;j>=1;j--)
            {
                if(hj[j]+b[j]<=mid-i)
                {
                    hj[j]+=b[j];
                    flag=1;
                    break;
                }
            }
            if(!flag)
            {
                l=mid+1;
                break;
            }
        }
        if(flag)
            r=mid;
    }
    cout<<l<<endl;

usaco4.4.1
开始做宽搜，结果可想而知。。。。
然后想找规律，结果仍无果
后来写深搜就过了。。。
此题搜索优化剪枝很明显，只让W往右走，Z往左走

void dfs(int x)
{
    if(x==(n+2)*n)
    {
        bool flag=1;
        for(int i=0;i<n;i++)
            if(now[i]!='B')
                flag=0;
        if(now[n]!='_'||flag==0)
        return ;
        for(int i=1;i<=x;i++)
        {
            cout<<op[i-1]+1;
            if(i%20==0)
                cout<<endl;
            else
                cout<<" ";
        }
        num=1;
        return ;
    }   
    if(num==1)
        return ;
    int df=last;
    if(w>=2&&last!=w-2)
    {
        if(now[w-1]=='B'&&now[w-2]=='W')
        {
            swap(now[w-2],now[w]);
            last=w;
            w-=2;
            op[x]=w;
            dfs(x+1);
            w+=2;
            last=df;
            swap(now[w-2],now[w]);
        }
    }
    if(w>=1&&last!=w-1)
    {
        if(now[w-1]=='W')
        {
            swap(now[w-1],now[w]);
            last=w;
            w-=1;
            op[x]=w;
            dfs(x+1);
            w+=1;
            last=df;
            swap(now[w-1],now[w]);
        }
    }
    if(w<2*n&&last!=w+1)
    {
        if(now[w+1]=='B')
        {
            swap(now[w+1],now[w]);
            last=w;
            w+=1;
            op[x]=w;
            dfs(x+1);
            w-=1;
            last=df;
            swap(now[w+1],now[w]);
        }
    }
    if(w<2*n-1&&last!=w+2)
    {
        if(now[w+1]=='W'&&now[w+2]=='B')
        {
            swap(now[w+2],now[w]);
            last=w;
            w+=2;
            op[x]=w;
            dfs(x+1);
            w-=2;
            last=df;
            swap(now[w+2],now[w]);
        }
    }
} 

usaco5.1.4
先二分长度，在同长度下hush，如果一个hush值里存了两个及以上的元素，就把他们o（长度)判一下，如果还符合，那就说明这个长度是可以的 
//所以说这里hush作用是优化，为什么一个hush值有两个及以上元素后还要再判一下呢？  。。。对自己hush函数不自信，这样可以更稳
另外，在此题中我终于找到了最稳的二分方法：

int l,r;
while(l<r-1)
{
    int mid=(l+r)/2;
    if(pan(mid))
        l=mid;
    else
        r=mid-1;
}
if(pan(r))
    ans=r;
else
    ans=l;

就是这样的格式

for(int i=1;i<n;i++)
        score[i]=music[i+1]-music[i];
    int l=4,r=2500;
    while(l<r-1)
    {
        int mid=(l+r)/2;
        for(int i=0;i<=99996;i++)
            if(!hush[i].empty())
                hush[i].clear();
        for(int i=1;i<=n-mid;i++)
        {
            int hj=gethush(i,mid);
            hush[hj].push_back(i);
        }
        bool flag=0;
        for(int k=0;k<=99996;k++)
        {
            if(flag==1)
                break;
            if(hush[k].empty())
                continue;
            if(hush[k].size()==1)
                continue;
            for(int i=0;i<hush[k].size()-1;i++)
            {
                if(flag==1)
                    break;
                for(int j=i+1;j<hush[k].size();j++)
                {
                    if(flag==1)
                        break;
                    if(hush[k][j]<=hush[k][i]+mid)
                        continue;
                    flag=1;
                    for(int jk=0;jk<mid;jk++)
                    {
                        if(score[hush[k][j]+jk]!=score[hush[k][i]+jk])
                        {
                            flag=0;
                            break;
                        }
                    }
                }
            }
        }
        if(flag==1)
            l=mid;
        else
            r=mid-1;
    }
    for(int i=0;i<=99996;i++)
            if(!hush[i].empty())
                hush[i].clear();
    for(int i=1;i<=n-r;i++)
    {
        int hj=gethush(i,r);
        hush[hj].push_back(i);
    }
    bool flag=0;
    for(int k=0;k<=99996;k++)
    {
        if(flag==1)
            break;
            if(hush[k].empty())
            continue;
            if(hush[k].size()==1)
                continue;
            for(int i=0;i<hush[k].size()-1;i++)
            {
                if(flag==1)
                    break;
                for(int j=i+1;j<hush[k].size();j++)
                {
                    if(flag==1)
                        break;
                    if(hush[k][j]<=hush[k][i]+r)
                        continue;
                    flag=1;
                    for(int jk=0;jk<r;jk++)
                    {
                        if(score[hush[k][j]+jk]!=score[hush[k][i]+jk])
                        {
                            flag=0;
                            break;
                        }
                    }
                }
            }
        }
    if(flag==0&&l==4)
    {`
`
        cout<<0<<endl;
        return 0;
    }
    if(flag==0)
    cout<<l+1<<endl;
    else
    cout<<r+1<<endl;