久久精品国产只有精品66 ,精品人妻伦九区久久AAA片69,亚洲国产成人精品无码久久久久久综合

最��费用最大流��法

lee1r — Thu, 01 Apr 2010 15:04:00 GMT

基本思�\�Q�每�ơ��用SPFA求出一条可增广��的最短�\�Q�对最短�\上的��进行增��；重复上述�q�程�Q�直至不存在可增�q��\�?br>以下是我的代码，仅供参考：

#include<stdio.h>
#define maxn 507
#define INF 200000007
FILE *fin=fopen("data.in","r"),*fout=fopen("data.out","w");
typedef struct
{
    long count,front,rear,item[maxn];
}queue;
void Clear(queue &q)
{
    q.count=0;q.front=0;q.rear=-1;
}
void Push(queue &q,long x)
{
    q.count++;q.rear++;
    if(q.rear>=maxn) q.rear=0;
    q.item[q.rear]=x;
}
void Pop(queue &q,long &x)
{
    q.count--;x=q.item[q.front];
    q.front++;
    if(q.front>=maxn) q.front=0;
}
bool Empty(queue &q)
{
    return (q.count==0);
}

long n,m,cap[maxn][maxn],cost[maxn][maxn];
long s,t,minc,maxf,flow[maxn][maxn];
long min(long a,long b)
{return (a<b?a:b);}
void input()
{
    fscanf(fin,"%ld%ld",&n,&m);
    for(long i=1;i<=n;i++)
      for(long j=1;j<=n;j++)
      {
         cap[i][j]=0;cost[i][j]=INF;
      }
    for(long i=1;i<=m;i++)
    {
       long a,b,c,d;
       fscanf(fin,"%ld%ld%ld%ld",&a,&b,&c,&d);
       cap[a][b]=c;cost[a][b]=d;
    }
}
void Mincost_Maxflow()
{
    long tmp,d[maxn],father[maxn];
    bool inq[maxn];
    queue q;Clear(q);
    s=1;t=n;
    for(long i=1;i<=n;i++)
      for(long j=1;j<=n;j++)
        flow[i][j]=0;
    minc=0;maxf=0;
    while(true)
    {
       for(long i=1;i<=n;i++)
       {
          d[i]=(i==s?0:INF);
          father[i]=0;
          inq[i]=false;
       }
       d[s]=0;Push(q,s);inq[s]=true;
       while(!Empty(q))
       {
          long i;Pop(q,i);inq[i]=false;
          for(long j=1;j<=n;j++)
            if(cap[i][j]>flow[i][j]&&cost[i][j]<INF&&d[i]+cost[i][j]<d[j])
            {
               d[j]=d[i]+cost[i][j];
               father[j]=i;
               if(!inq[j])
               {Push(q,j);inq[j]=true;}
            }
       }
       if(d[t]>=INF) break;
       tmp=INF;
       for(long i=t;i!=s;i=father[i]) tmp=min(tmp,cap[father[i]][i]-flow[father[i]][i]);
       for(long i=t;i!=s;i=father[i])
       {
          flow[father[i]][i]+=tmp;
          flow[i][father[i]]-=tmp;
       }
       minc+=tmp*d[t];
       maxf+=tmp;
    }
}
void output()
{
    fprintf(fout,"Mincost := %ld\nMaxflow := %ld\n",minc,maxf);
}
int main()
{
    input();
    Mincost_Maxflow();
    output();
return 0;
}

lee1r 2010-04-01 23:04 发表评论

数组模拟链表操作

lee1r — Tue, 16 Mar 2010 14:39:00 GMT

很久��q��道链表可以用数组来模拟（其实很多数据�l�构数组都可以实玎ͼ��Q�一开始感觉用数组模拟�q�不��单吗�Q�于是很长的一�D�|��间内都没有去写这个程序。今天突然想��C��Q�想��d��现它�Q�结果竟然思考了大概20min才想起如何构造数据结构，看来�E�序�q�得多动手实��c�?br>以下是我的代码：
insert(a,b)�Q�在链表中��gؓb的元素前面插入a�Q�如果找不到b�Q�将a插入链表末端�Q?br>print()�Q�遍历整个链表，�q�输出�?br>

#include<stdio.h>
#include<string.h>
#define maxn 1007
long n,a[maxn],next[maxn];
void insert(long x,long y)
{
    long p=0;
    n++;a[n]=x;
    while(next[p]&&a[next[p]]!=y)
      p=next[p];
    next[n]=next[p];
    next[p]=n;
}
void print()
{
    long p=next[0];
    bool first=true;
    while(p)
    {
       if(first) first=false;
       else printf(" ");
       printf("%ld",a[p]);
       p=next[p];
    }
}
int main()
{
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    long m,a,b;
    char cmd[maxn];
    n=0;
    memset(next,0,sizeof(next));
    scanf("%ld",&m);
    while(m--)
    {
       scanf("%s",cmd);
       if(cmd[0]=='I')
       {
          scanf("%ld%ld",&a,&b);
          insert(a,b);
       }
       else
       {
          print();putchar('\n');
       }
    }
return 0;
}

lee1r 2010-03-16 22:39 发表评论

Splay树的基本操作

lee1r — Fri, 12 Mar 2010 14:28:00 GMT

最�q�对树型数据�l�构特别感兴��！
以下是我的Splay树代码：

#include<stdio.h>
#define maxn 10007
typedef struct
{
    long data,fa,ls,rs;
}Node;
Node splay[maxn];
long m,root;
long n;
void Zig(long node)
{
    long t=splay[node].fa;
    splay[t].rs=splay[node].ls;
    if(splay[node].ls)
      splay[splay[node].ls].fa=t;
    splay[node].fa=splay[t].fa;
    splay[node].ls=t;
    if(splay[t].fa)
    {
       if(t==splay[splay[t].fa].ls) splay[splay[t].fa].ls=node;
       else splay[splay[t].fa].rs=node;
    }
    splay[t].fa=node;
}
void Zag(long node)
{
    long t=splay[node].fa;
    splay[t].ls=splay[node].rs;
    if(splay[node].rs)
      splay[splay[node].rs].fa=t;
    splay[node].fa=splay[t].fa;
    splay[node].rs=t;
    if(splay[t].fa)
    {
       if(t==splay[splay[t].fa].ls) splay[splay[t].fa].ls=node;
       else splay[splay[t].fa].rs=node;
    }
    splay[t].fa=node;
}
void Splay(long node)
{
    long t;
    while(splay[node].fa)
    {
       t=splay[node].fa;
       if(splay[t].fa==0)
       {
          if(node==splay[t].ls) Zag(node);
          else Zig(node);
          break;
       }
       if(t==splay[splay[t].fa].ls)
       {
          if(node==splay[t].ls)
          {Zag(t);Zag(node);}
          else {Zig(node);Zag(node);}
       }
       else
       {
          if(node==splay[t].ls)
          {Zag(node);Zig(node);}
          else {Zig(t);Zig(node);}
       }
    }
    root=node;
}
void Insert(long x)
{
    long p,q;
    m++;
    splay[m].data=x;
    splay[m].fa=splay[m].ls=splay[m].rs=0;
    if(root==0)
    {
       root=m;return;
    }
    for(p=root;p; )
    {
       q=p;
       if(x<=splay[p].data) p=splay[p].ls;
       else p=splay[p].rs;
    }
    splay[m].fa=q;
    if(x<=splay[q].data) splay[q].ls=m;
    else splay[q].rs=m;
    Splay(m);
}
int main()
{
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    scanf("%ld",&n);
    m=root=0;
    for(long i=1;i<=n;i++)
      splay[i].data=splay[i].fa=splay[i].ls=splay[i].rs=0;
    for(long i=1;i<=n;i++)
    {
       long t;
       scanf("%ld",&t);
       Insert(t);
    }
    Splay(1);
    for(long i=1;i<=n;i++)
    printf("No.%ld data.%ld fa.%ld ls.%ld rs.%ld\n",i,splay[i].data,splay[i].fa,splay[i].ls,splay[i].rs);
return 0;
}

lee1r 2010-03-12 22:28 发表评论

Miller-Rabbin素数��试

lee1r — Sat, 20 Feb 2010 08:02:00 GMT

如果n是一个正整数�Q�如果存在和n互素的正整数a满��a^n-1≡1(mod n)�Q�我们说n是基于a的伪素数。如果一个数是伪素数�Q�它几乎肯定是素数�?br>以下是我的miller_rabbin素数��试的代码：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define maxTest 5
typedef long long int64;
int64 random(int64 n)
{
    return (int64)((double)rand()/RAND_MAX*n+0.5);
}
int64 mod_exp(int64 a,int64 b,int64 n)
{
    long ans;
    if(b==1) return a%n;
    ans=mod_exp(a,b/2,n);
    if(b%2==0) return ans*ans%n;
    else return ans*ans%n*a%n;
}
bool miller_rabbin(int64 n)
{
    for(long i=1;i<=maxTest;i++)
    {
       long a=random(n-2)+1;
       if(mod_exp(a,n-1,n)!=1) return false;
    }
    return true;
}
int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/
    srand(time(NULL));
    int64 n;
    while(scanf("%I64d",&n)==1)
      if(miller_rabbin(n))
        printf("True\n\n");
      else printf("False\n\n");
return 0;
}

lee1r 2010-02-20 16:02 发表评论

�W�一个线�D�|��E�序

lee1r — Wed, 17 Feb 2010 05:33:00 GMT

被线�D�|��折磨了这么久�Q�今天终于把它给写出来了……用的是数�l�模拟树�?br>功能�Q�创��Z��늺��D�|��Q�给a[i]加上一个��|��求一个区间的最大倹{�?br>以下是我的代码：

/*
    Author >>  Lee1R
    Time >> 02,16,2010 23:37
//*/

#include<stdio.h>
const long maxn=10007;
typedef struct NODE
{
    long a,b,sum;
    long left,right;
}node;
long n,m,a[maxn];
node tree[maxn];long tot;
void creat(long begin,long end)
{
    long now,mid=(begin+end)/2;
    tot++;now=tot;
    tree[now].a=begin;tree[now].b=end;
    if(end-begin<=1)
    {
       tree[now].left=-1;
       tree[now].right=-1;
       tree[now].sum=a[begin]+a[end];
    }
    else
    {
       tree[now].left=tot+1;creat(begin,mid);
       tree[now].right=tot+1;creat(mid,end);
       tree[now].sum=tree[tree[now].left].sum+tree[tree[now].right].sum-a[mid];
    }
}
void add(long pos,long det,long node)
{
    long begin=tree[node].a,end=tree[node].b,mid=(begin+end)/2;
    tree[node].sum+=det;
    if(end-begin==1) return;
    if(pos>=begin&&pos<=mid)
      add(pos,det,tree[node].left);
    if(pos>=mid&&pos<=end)
      add(pos,det,tree[node].right);
}
long getsum(long begin,long end,long node)
{
    long re=0,t=(tree[node].a+tree[node].b)/2;
    if(tree[node].b-tree[node].a==1) re=tree[node].sum;
    else
    {
       if(end<=t)
         re=getsum(begin,end,tree[node].left);
       else if(begin>=t)
         re=getsum(begin,end,tree[node].right);
       else
         re=getsum(begin,t,tree[node].left)+getsum(t,end,tree[node].right)-a[t];
    }
    return re;
}
int main()
{
    //*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/
    scanf("%ld",&n);
    for(long i=1;i<=n;i++) scanf("%ld",&a[i]);
    tot=0;creat(1,n);
    //  Init
    scanf("%ld",&m);
    for(long i=1;i<=m;i++)
    {
       long t,b,c;
       scanf("%ld%ld%ld",&t,&b,&c);
       switch(t)
       {
          case 1:
               a[b]+=c;
               add(b,c,1);
               break;
          case 2:
               if(b==c) printf("%ld\n",a[b]);
               else printf("%ld\n",getsum(b,c,1));
               break;
       }
    }
return 0;
}

lee1r 2010-02-17 13:33 发表评论

各顶炚w��的最短�\——Floyed��法

lee1r — Thu, 21 Jan 2010 15:10:00 GMT

以下是我的代码：

for(long k=1;k<=n;k++)
  for(long i=1;i<=n;i++)
    for(long j=1;j<=n;j++)
      if(k!=i&&i!=j&&j!=k)
        d[i][j]=min(d[i][j],d[i][k]+d[k][j])

lee1r 2010-01-21 23:10 发表评论

最��生成树——Kruskal��法

lee1r — Thu, 21 Jan 2010 15:04:00 GMT

以下是我的代码：

#include<stdio.h>
const long maxn=107,INF=10000007;
typedef struct
{
    long u,v,w;
}edge;
long n,m,g[maxn][maxn],mst;
edge E[maxn*maxn];
long f[maxn];
long Getf(long x)
{
    if(f[x]==x) return x;
    f[x]=Getf(f[x]);
    return f[x];
}
bool Judge(long x,long y)
{
    return (Getf(x)==Getf(y));
}
void Union(long x,long y)
{
    long i=Getf(x),j=Getf(y);
    if(i==j) return ;
    f[i]=j;
}
void Qsort(edge *a,long begin,long end)
{
    long i=begin,j=end,mid=a[(begin+end)/2].w;
    edge t;
    do{
         while(a[i].w<mid) i++;
         while(a[j].w>mid) j--;
         if(i<=j)
         {
            t=a[i];a[i]=a[j];a[j]=t;
            i++;j--;
         }
    }while(i<=j);
    if(begin<j) Qsort(a,begin,j);
    if(i<end)   Qsort(a,i,end);
}
int main()
{
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    scanf("%ld%ld",&n,&m);
    for(long i=1;i<=n;i++)
      for(long j=1;j<=n;j++)
        g[i][j]=INF;
    for(long i=1;i<=m;i++)
      scanf("%ld%ld%ld",&E[i].u,&E[i].v,&E[i].w);
    //  Read In
    Qsort(E,1,m);
    //  Qsort
    for(long i=1;i<=n;i++) f[i]=i;
    //  Init
    mst=0;
    long i=0,j=1;
    while(i<n-1)
    {
       long a=E[j].u,b=E[j].v;
       if(!Judge(a,b))
       {
          mst+=E[j].w;
          Union(a,b);
          i++;
       }
       j++;
    }
    printf("%ld\n",mst);
return 0;
}

lee1r 2010-01-21 23:04 发表评论

lee1r — Thu, 21 Jan 2010 14:44:00 GMT

以下是我的代码：

const long maxn=1007;
typedef struct
{
    long front,rear,count,item[maxn];
}queue;
void clear(queue &q)
{
    q.count=0;
    q.front=0;
    q.rear=-1;
}
bool empty(queue &q)
{
    return (q.count==0);
}
void put(queue &q,long x)
{
    q.rear++;
    q.item[q.rear]=x;
    q.count++;
}
void get(queue &q,long &x)
{
    x=q.item[q.front];
    q.front++;
    q.count--;
}

lee1r 2010-01-21 22:44 发表评论

栈的常用操作函数

lee1r — Thu, 21 Jan 2010 14:39:00 GMT

以下是我的代码：

#include<stdio.h>
const long maxn=1007;
typedef struct
{
    long top,count,item[maxn];
}stack;
void clear(stack &q)
{
    q.count=0;
    q.top=-1;
}
bool empty(stack &q)
{
    return (q.count==0);
}
void push(stack &q,long x)
{
    q.top++;
    q.item[q.top]=x;
    q.count++;
}
void pop(stack &q,long &x)
{
    x=q.item[q.top];
    q.top--;
    q.count--;
}
int main()
{
    stack s;clear(s);
    for(long i=1;i<=10;i++) push(s,i);
    while(!empty(s))
    {
       long x;
       pop(s,x);
       printf("%ld\n",x);
    }
    getchar();
return 0;
}

lee1r 2010-01-21 22:39 发表评论

增广路算法——Edmonds-Karp��法

lee1r — Wed, 20 Jan 2010 13:58:00 GMT

以下是我的代码：

#include<stdio.h>
const long maxn=107,INF=2000007;
typedef struct
{
    long front,rear,count,item[maxn];
}queue;
void clear(queue &q)
{
    q.count=0;
    q.front=0;
    q.rear=-1;
}
bool empty(queue &q)
{
    return (q.count==0);
}
void push(queue &q,long x)
{
    q.rear++;
    q.item[q.rear]=x;
    q.count++;
}
void pop(queue &q,long &x)
{
    x=q.item[q.front];
    q.front++;
    q.count--;
}
//  Queue

long n,m,cap[maxn][maxn],flow[maxn][maxn];
long s,t,fmax;

long min(long a,long b)
{
    return (a<b?a:b);
}
void read()
{
    scanf("%ld%ld",&n,&m);
    s=1;t=n;
    for(long i=1;i<=n;i++)
      for(long j=1;j<=n;j++)
        cap[i][j]=0;
    for(long i=1;i<=m;i++)
    {
       long a,b,w;
       scanf("%ld%ld%ld",&a,&b,&w);
       cap[a][b]=w;
    }
}
void EK()
{
    long tmp[maxn],father[maxn];
    queue q;clear(q);
    for(long i=1;i<=n;i++)
      for(long j=1;j<=n;j++)
        flow[i][j]=0;
    fmax=0;
    while(true)
    {
       for(long i=1;i<=n;i++) tmp[i]=father[i]=0;
       tmp[s]=INF;
       push(q,s);
       while(!empty(q))
       {
          long i;
          pop(q,i);
          for(long j=1;j<=n;j++)
            if(!tmp[j]&&cap[i][j]>flow[i][j])
            {
               tmp[j]=min(tmp[i],cap[i][j]-flow[i][j]);
               father[j]=i;
               push(q,j);
            }
       }
       if(tmp[t]==0) break;
       for(long i=t;i!=s;i=father[i])
       {
          flow[father[i]][i]+=tmp[t];
          flow[i][father[i]]-=tmp[t];
       }
       fmax+=tmp[t];
    }
    printf("%ld\n",fmax);
}
int main()
{
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    read();
    EK();
return 0;
}

lee1r 2010-01-20 21:58 发表评论

lee1r — Sun, 10 Jan 2010 06:05:00 GMT

bsearch()功能�Q�在有序数组a的[begin,end)区间中查找数字x�Q�如果找不到�Q�返�?�Q?br>low_search()功能�Q�在有序数组a的[begin,end)区间中插入一个数字x�Q�x��量向前插入�Q�返回x应该插入的位�|�；
high_search()功能�Q�在有序数组a的[begin,end)区间中插入一个数字x�Q�x��量向后插入�Q�返回x应该插入的位�|��?br>以下是我的代码：

#include<stdio.h>
long bsearch(long *a,long begin,long end,long x)
{//  [begin,end)
    long mid;
    while(begin<end)
    {
       mid=(begin+end)/2;
       if(a[mid]==x) return mid;
       else if(a[mid]>x) end=mid;
       else begin=mid+1;
    }
    return 0;
}
long low_search(long *a,long begin,long end,long x)
{
    long mid;
    while(begin<end)
    {
       mid=(begin+end)/2;
       if(a[mid]>=x) end=mid;
       else begin=mid+1;
    }
    return begin;
}
long high_search(long *a,long begin,long end,long x)
{
    long mid;
    while(begin<end)
    {
       mid=(begin+end)/2;
       if(a[mid]<=x) begin=mid+1;
       else end=mid;
    }
    return begin;
}
int main()
{
    //*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/
    const long maxn=108;
    long n=0,a[maxn];
    while(scanf("%ld",&a[n+1])==1) n++;

return 0;
}

lee1r 2010-01-10 14:05 发表评论

lee1r — Sat, 09 Jan 2010 10:26:00 GMT

#include<stdio.h>
void msort(long *a,long *t,long begin,long end)
{
    long mid=(begin+end)/2,p=begin,q=mid+1,i=begin;
    if(begin<end)
    {
       msort(a,t,begin,mid);
       msort(a,t,mid+1,end);
       while(i<=end)
       {
          if(q>end||a[p]<=a[q]) t[i++]=a[p++];
          else t[i++]=a[q++];
       }
       for(long i=begin;i<=end;i++) a[i]=t[i];
    }
}
int main()
{
    //*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/
    const long maxn=108;
    long n=0,a[maxn],t[maxn];
    bool first=true;
    while(scanf("%ld",&a[n+1])==1) n++;
    //  Read In
    msort(a,t,1,n);
    //  M_sort
    for(long i=1;i<=n;i++)
    {
       if(first) first=false;
       else printf(" ");
       printf("%ld",a[i]);
    }
    putchar('\n');
return 0;
}

在上面的归�ƈ排序�E�序的基��上，很容易修改得出求一个序列逆序对个数的�E�序�?br>以下是我的代码，只给出函敎ͼ�main()与上面的基本相同�Q?br>

long count(long *a,long *t,long begin,long end)
{
    long mid=(begin+end)/2,p=begin,q=mid+1,i=begin,re=0;
    if(begin<end)
    {
       re+=count(a,t,begin,mid);
       re+=count(a,t,mid+1,end);
       while(i<=end)
       {
          if(q>end||a[p]<=a[q]) t[i++]=a[p++];
          else
          {
             t[i++]=a[q++];
             re+=mid-p+1;
          }
       }
       for(long i=begin;i<=end;i++) a[i]=t[i];
    }
    return re;
}

lee1r 2010-01-09 18:26 发表评论

对于09 NOIp

lee1r — Wed, 06 Jan 2010 10:28:00 GMT

一转眼�Q�一�q�的旉��又过��M��Q�一�q�一�ơ的NOIp又要��C��。经�q�一�q�的学习�Q�感觉自己比原来�q�步了许多。在09NOIp中对自己提出几点要求和注意事��V�?/span>

1�?/span>时刻保持冷静的头脑；

2�?/span>不论是什么题目（做过或是没做�q�，水题或难题）�Q�都要仔�l�阅读题目；

3�?/span>开始编码之前，先写出程序大�UԌ��写出需要编写的函数�Q?/span>

4�?/span>��量不要使用全局变量�Q�特别是用于循环的变量）�Q�一定避免变量重名；

5�?/span>搜烦�Ӟ��设计的剪枝策略无法出解时�Q�在保证正确性的情况下，适当攑֮�搜烦条�g�Q?/span>

6�?/span>动态规划时�Q�一定时��L��状态的定义�Q�确定边界条�Ӟ��

7�?/span>模拟�Ӟ��理清逻辑关系�Q?/span>

8、在不媄响结果的时候，函数调用可以使用地址传递，效率较高�?/font>

lee1r 2010-01-06 18:28 发表评论

lee1r — Wed, 06 Jan 2010 10:23:00 GMT

void heap_adjust(long a[],long begin,long end)
{
    long i,m;
    m=a[begin];
    for(i=begin*2;i<=end;i*=2)
    {
       if( i<end && a[i]>a[i+1] )
          i++;
       if( m<=a[i] )
          break;
       a[begin]=a[i];
       begin=i;
    }
    a[begin]=m;
}    /*调整�Q��之成��Z��个堆*/

Ps�Q?/font>

1.对堆的调整从��至下进行�?/font>

2.创徏一个新堆应该从最后一个叶�l�点的父�l�点开始逐步向上调整�?/font>

3.对heap[s..m]能够调整成功�Q�需要heap[s+1..m]严格满��堆的定义�?/font>

lee1r 2010-01-06 18:23 发表评论

链表常用操作

lee1r — Wed, 06 Jan 2010 10:22:00 GMT

#include<stdio.h>
#include<stdlib.h>
struct node
{
       int data;
       struct node *next;
};//�l�构�c�d��的说�?/span>

struct node *stack(struct node *head)
{
     int i;
     struct node *p;
     p = (struct node*)malloc(sizeof(struct node));
     p->next = NULL;
     for(i=0;i<10;i++)
       {
         head = (struct node*)malloc(sizeof(struct node));
         p->data = i;
         head->next = p;
         p = head;;
       }
     return (head);
}//�?/span>

struct node *team(struct node *head)
{
     int i;
     struct node *tail,*p;
     head = (struct node*)malloc(sizeof(struct node));
     tail = head;
     for(i=0;i<10;i++)
       {
         p = (struct node*)malloc(sizeof(struct node));
         p->data = i;
         tail->next = p;
         tail = p;
       }
     tail->next = NULL;
     return (head);
}//队列

void print_list(struct node *head)
{
     struct node *p;
     p = head->next;
     printf("Begin");
     while(p != NULL)
       {
         printf("->%d",p->data);
         p = p->next;
       }
     printf("->End\n");
}//链表输出

void detele_x(struct node *head,int x)
{
     struct node *p,*q;
     p = head;
     q = head->next;
     while(q->data != x && q->next != NULL)
       { p = q; q = q->next; }
     if(q->data == x)
       p->next = q->next;
     free(q);
}//删除数据域�ؓx的结�?/span>

void add_x_y(struct node *head,int x,int y)
{
     struct node *add_new,*p,*q;
     add_new = (struct node*)malloc(sizeof(struct node));
     add_new->data = x;
     p = head;
     q = head->next;
     while(q != NULL && q->data != y)
       { p = q; q = q->next; }
     p->next = add_new;
     add_new->next = q;
}//在数据�ؓy的结点前插入数据域�ؓx的结�?br>

lee1r 2010-01-06 18:22 发表评论

lee1r — Wed, 06 Jan 2010 10:20:00 GMT

//------------------------------------------------------------

对于环�Ş的动态规划，

可以把数�l�下标复制一份然后进行动态规�?/font>

//------------------------------------------------------------

在动态规划的具体�~�程中，可能许多时候写��Z��正确的状态�{�U�L��E�，但编写后的程序却得不到正��解�Q�这很有可能是因为动态规划的循环的顺逆序�Q�或者��@环的内外层出��C��错误�?/font>

在这里忽略其他资料中的理论知识，而具体说动态规划是如何实现的�?/font>

// 在这里的�l�出的全部代码都没有�l�过调试而直接写�?/span>

// 如果出现错误�Q�请指出

�?/span>01背包开始说赗��?/span>

�E�微掌握动态规划的人都可以熟练地写出如下代码：

for(i=1;i<=n;i++)
for(j=v;j>=c[i];j--)
d[j]=max(d[j],d[j-c[i]]+w[i])�Q?br>

一般的动态规划都是先枚�D状态再枚�D决策�Q�可能初学者不明白以上的代码是怎么回事�Q�因��是降�l�之后的状态表�C�，降维之前的是�Q?/font>

d[i][j]=max(d[i-1][j],d[i-1][j-c[i]]+w[i])�Q?/span>

之所以可以降�l�是因�ؓ�Q�观察状态�{�U�L��E�，�W?/span>i�ơ的决策只与�W?/span>i-1�ơ所记录的状态有养I��于是惻I��能不能有一�U�方法只用一�l�数�l�，��可以在状态�{�U�能够正��进行？�{�案是肯定的�Q�那��是�W�二层��用逆序循环�?/span>

NOIp 2006 金明的预��方�?/span>

先处理一下给出的物品�Q�分成若�q�组�Q��{化�ؓ分组背包问题�?/font>

写出分组背包的状态�{�U�L��E�：

d[k][j]=max(d[k-1][j],d[k-1][j-c[k][i]]+w[k][i])�Q?/span>

对于分组背包�Q�给出如下代码：

for 所有组k
  for j=V to 0
    for 所有物品i属于�l�k
      d[j]=max(d[j],d[j-c[k][i]]+w[k][i])�Q?br>

// 《背包问题九讌Ӏ�中的代码似乎有炚w��?/span>

同样�Q�先观察状态�{�U�L��E�，�q�是只取决于�W?/span>k-1�l�记录的状态，又要使每�l�中物品只选一件或者一仉��不选。这样就��定了分�l�背包只能是上面的��@环次序，因�ؓ只有�q�样在第k�l�决�{�的时候才能保证从�W?/span>k-1�l�的状态�{�U�而来�Q�简单地说就是，在第二层固定了前k�l�物品占用的�I�间�Q�那么无论选择哪一�?/span>i�Q�最�l�这个状态都只能被第k�l�的一个物品占用；试想如果像《背包问题九讌Ӏ�中那样把第二层循环和第三层循环颠倒过来，那么��有可能�W?/span>k层的状态由�W?/span>k层的状态�{�U�而来�Q�从而不能保证最多选择一件物品�?/span>

Vijos GF

二维费用的背包�?/font>

状态�{�U�L��E�直接给出如下：

d[i][j][k]=max(d[i-1][j][k],d[i-1][j-c1[i]][k-c2[i]]+w[i])�Q?/span>

同样可以降到二维�Q�因为是每个GF只能选择一�ơ（题目中好像没有这么说�Q�很久之前做的了�Q�不太记得了�Q�但是现实生�z�M��的经验告诉我们每�?/span>GF只能选择一�ơ）�Q�所以在循环枚�Dj�?/span>k的时候要使用逆序�?/span>

Vijos 情敌

当然可以理解为和“金明的预��方�?#8221;一��P��是有依赖关系的背包问题，但是�q�道题却在数据的规模上告诉我们用那种�Ҏ��是不可行的。更好的做法是搜索和动态规划结合，每次枚�D��情敌在第一个月消灭、第二个月消灭、第三个月消灭（即不消灭�Q�，然后对其余情敌进行动态规划�?/font>

省略搜烦部分�Q�而着重说说动态规划�?/font>

状态�{�U�L��E�：

d[i][j][k]=max(d[i-1][j][k],d[i-1][j-c1[i]][k],d[i-1][j][k-c2[i]])�Q?/span>

�׃��有可能某个超�U�情敌没有被消灭�Q�而在枚�Di的时候枚举了�q�个��情敌�Q�如果在�q�时直接判断�?/span>continue�Q�可能造成d[i]层的�I�缺�Q�以至于d[i+1]层的错误。所以在处理�q�样可能出现某一层出现空�~�的情况�Ӟ��要把�I�缺的那一层全部从它的上一层把状态��承下来，以保证后来的状态�{�Uȝ��正确�?/span>

�ȝ��一下�?/font>

对于一道题目写出状态�{�U�L��E�之后，�E�序的实现有时候是显而易见的�Q�但有时候却又需要思考一番。这时候还是需要立��于状态�{�U�L��E�，另外�q�要考虑到题目中的一些限制条�Ӟ��设计合适的循环��逆序和内外层�?/font>

//------------------------------------------------------------

lee1r 2010-01-06 18:20 发表评论

优化的Bellman-Ford——SPFA

lee1r — Wed, 06 Jan 2010 10:17:00 GMT

SPFA的基本思�\是：只有被修改过最短�\的顶点，才有可能��D��修改与它��L��的顶点的最短�\。于是很�Ҏ��惛_��用一个队列维护�?br>以下是我的代码：

#include<stdio.h>
#define min(a,b) (a
const long maxn=507;
const long INF=100000007;
typedef struct
{
    long front,rear,count,item[maxn];
}queue;
void clear(queue &q)
{
    q.count=0;
    q.front=0;
    q.rear=-1;
}
bool empty(queue &q)
{
    return (q.count==0);
}
void push(queue &q,long x)
{
    q.rear++;
    q.item[q.rear]=x;
    q.count++;
}
long pop(queue &q)
{
    long x=q.item[q.front];
    q.front++;
    q.count--;
    return x;
}
//  Queue
typedef struct EDGE_NODE
{
    long u,v,w;
    struct EDGE_NODE *next;
}edge_node;
long n,m,d[maxn];
edge_node *a[maxn];
//  Var
void insert(long begin,long end,long weight)
{
    edge_node *p=new edge_node;
    p->u=begin;p->v=end;p->w=weight;
    p->next=a[begin]->next;
    a[begin]->next=p;
}
bool bellman_ford(long s)
{
    bool in[maxn];
    long in_num[maxn];
    queue q;clear(q);
    edge_node *p;
    for(long i=1;i<=n;i++)
    {
       d[i]=(i==s?0:INF);
       in[i]=false;
       in_num[i]=0;
    }
    push(q,s);
    in[s]=true;
    in_num[s]++;
    while(!empty(q))
    {
       long i=pop(q);in[i]=false;
       for(p=a[i]->next;p;p=p->next)
       {
          long j=p->v;
          if(d[i]+p->w<d[j])
          {
             d[j]=d[i]+p->w;
             if(!in[j])
             {
                push(q,j);
                in[j]=true;
                in_num[j]++;
                if(in_num[j]>n) return false;
             }
          }
       }
    }
    return true;
}
int main()
{
    //*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/
    scanf("%ld%ld",&n,&m);
    for(long i=1;i<=n;i++)
    {
       a[i]=new edge_node;
       a[i]->next=NULL;
    }
    for(long i=1;i<=m;i++)
    {
       long a,b,w;
       scanf("%ld%ld%ld",&a,&b,&w);
       insert(a,b,w);
       insert(b,a,w);
    }
    if(bellman_ford(1))
    {
       for(long i=1;i<=n;i++) printf("%ld ",d[i]);
       putchar('\n');
    }
    else printf("Error\n");
return 0;
}

lee1r 2010-01-06 18:17 发表评论

搜烦��法��结

lee1r — Wed, 06 Jan 2010 10:11:00 GMT

最�q�一�D�|��间仔�l�地学习了搜索方面的书籍�Q�对搜烦有了一些新的体会。搜索的��法有很多，从最��单的DFS、BFS�Q�到�E�稍有点优化的�P代加深、�P代加宽，再到A*、IDA*……感觉对于搜烦的学习和�q�用�Q�绝对不能只局限于�q�些常用的方法中�Q�而应该对各个�Ҏ��有一个整体的把握�Q�分析各�U�方法的优点和缺点，学会比较各种�Ҏ��的时�I�性能�Q�针寚w��目的特点入手�?/font>

DFS

最常用的一�U�搜索方法，几乎学过搜烦的都会。适用于搜索的深度已知�Q�比较适合搜烦全部解。常用的优化�Ҏ��是在�l�点扩展时加入剪枝策略�?/font>

BFS

相对与DFS可能用得��了点，但也是必会的基本�Ҏ��。如果搜索的深度不知�Q�DFS可能陷入��d�@环，同时�Q�如果空间上可以承受�Q�这时候可以考虑BFS。侧重寻求最优解�?/font>

双向�q�度优先搜烦

适用于知道目标状态，每次扩展两个�l�点�Q�但不一定非要是交替扩展�Q�扩展方式很多。如果目标状态始�l�不变，而有多个初始状态，��可�?#8220;周界搜烦”。要注意的是�Q�如何判断已�l�扩展结�Ҏ��否在另一端的�Ҏ��Q�是需要认真考虑�Q�选取最优判断方法的�?/font>

�q�代加深搜烦 ID

每次限制搜烦的深度，扑ֈ�解就停止�Q�否则加大深度再�ơ搜索。相对于DFS不会陷入��d�@环，相对于BFS不会在空间上有压力，也可以用来寻求最优解�Q�不�q�缺�Ҏ��重复搜烦�?/font>

�q�代加宽搜烦 IB

没有太多接触�Q�无�?#8230;…

按f(s)的值扩展结点，是一�U�启发式搜烦。需要两个表�Q�每�ơ判断是否在�?中、是否在表二中、同时在表一表二中，判断f(s)和f(s')的大��，选择是否替换。其中f(s)=g(s)+h(s)�Q�h(s)��Z��价函数。要求h函数相容�Q�对于这�U�说法，我自��q��理解��是�Q�状态每转移一�ơ，h减少量最多�ؓ1。A*��法求得的第一个解必是最优解。缺点依然是�I�间需求太大�?/font>

IDA*

�q�代加深的A*。每�ơ搜索加上一个深度限�Ӟ��扩展的时候判断最好情冉|��否会��过深度�Q�也��是一�U�极端法的剪枝思想。适用与深度不定，最优解的深度又不一定很深，而状态�{�Uȝ��方式又有很多�Q��得状态空间无法承受�?/font>

关于剪枝�Q?、可行性剪�?2、最优性剪�?/font>

具体操作�Ӟ��1、极端法 2、数学方�?/font>

lee1r 2010-01-06 18:11 发表评论

lee1r — Wed, 06 Jan 2010 10:05:00 GMT

�q�查集（Union-Find Sets�Q�的两种功能�Q�合�q�两个集合；查找一个元素属于哪个集合�?/font>

�q�查集的两个优化�Q�基于rank的启发式合�ƈ�Q��\径压�~��?/font>

以下是我的代�?/font>:

#include<stdio.h>
const long maxn=10008;
long n,f[maxn],rank[maxn];
void Init()
{
    for(long i=1;i<=n;i++)
    {
       f[i]=i;
       rank[i]=0;
    }
}
long Getf(long x)
{
    if(f[x]==x) return x;
    f[x]=Getf(f[x]);// 路径压羃
    return f[x];
}
bool Same(long x,long y)
{
    return (Getf(x)==Getf(y));
}
void Union(long x,long y)
{
    long fx=Getf(x),fy=Getf(y);
    if(fx!=fy)
    {
       if(rank[fx]==rank[fy])
       {
          f[fx]=fy;
          rank[fy]++;
       }
       else if(rank[fx]<rank[fy])
         f[fx]=fy;
       else f[fy]=fx;
    }// 启发式合�q?nbsp;
}
int main()
{
    n=10;
    Init();
return 0;
}

lee1r 2010-01-06 18:05 发表评论

拓扑排序(topo sort)

lee1r — Wed, 06 Jan 2010 09:49:00 GMT

#include<stdio.h>
const long maxv=108;
long v,e,count,a[maxv],used[maxv];
bool g[maxv][maxv],ans;
void init()
{
    scanf("%ld%ld",&v,&e);
    for(long i=1;i<=v;i++)
      for(long j=1;j<=v;j++)
        g[i][j]=false;
    for(long i=1;i<=e;i++)
    {
       long a,b;
       scanf("%ld%ld",&a,&b);
       g[a][b]=true;
    }
}
void dfs(long now)
{
    if(!ans) return;
    used[now]=-1;
    for(long i=1;i<=v;i++)
      if(g[now][i])
      {
         if(used[i]==-1)
         {
            ans=false;
            return;
         }
         else if(!used[i])
           dfs(i);
      }
    a[count]=now;count--;
    used[now]=1;
}
void toposort()
{
    long begin;
    ans=false;

    for(long i=1;i<=v;i++)
    {
       for(long j=1;j<=v;j++)
         if(g[j][i])
           break;
       begin=i;
       ans=true;
       break;
    }
    //  Find a Vertex to Start
    if(ans)
    {
       for(long i=1;i<=v;i++)
         used[i]=0;
       count=v;
       dfs(begin);
    }
    //  Topo_Sort
    if(ans)
    {
       bool first=true;
       for(long i=1;i<=v;i++)
       {
          if(first) first=false;
          else putchar(' ');
          printf("%ld",a[i]);
       }
       putchar('\n');
    }
    else
      printf("No answer.\n");
    //  Write down the Answer
}
int main()
{
    //*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/
    init();
    toposort();
return 0;
}

lee1r 2010-01-06 17:49 发表评论

久久精品国产只有精品66 ,精品人妻伦九区久久AAA片69,亚洲国产成人精品无码久久久久久综合

最���费用最大流���法

数组模拟链表操作

Splay树的基本操作

Miller-Rabbin素数���试

�W�一个线�D�|���E�序

各顶炚w��的最短�\——Floyed���法

最���生成树——Kruskal���法

栈的常用操作函数

增广路算法——Edmonds-Karp���法

对于09 NOIp

链表常用操作

优化的Bellman-Ford——SPFA

搜烦���法���结

拓扑排序(topo sort)

最��费用最大流��法

Miller-Rabbin素数��试

�W�一个线�D�|��E�序

各顶炚w��的最短�\——Floyed��法

最��生成树——Kruskal��法

增广路算法——Edmonds-Karp��法

搜烦��法��结