C++博客-ArcTan-文章分类-ACM-201203

poj3083(bfs+dfs)

wangs — Sat, 31 Mar 2012 12:43:00 GMT

http://poj.org/problem?id=3083

题意就是在图里遍历遍历：bfs+dfs.
哈哈，dfs，顺时针和逆时针，学会这个好方法真好。
刚刚开始好恶心恶心的说，没有找到好办法，经验太少了。嘿嘿，慢慢积累经验哈。

代码好丑，需要改改了：

#include
#include
#include
int t,n,m,xs,ys,xx,yy,least,right,left,step;
int a[45][45],vis[45][45],que[20005][2];
int go[4][2]= {{-1,0},{0,1},{1,0},{0,-1}};
int bfs(int x,int y)
{
    int head,tail,x1,y1,x2,y2,i;
    head=0;
    tail=1;
    que[1][0]=x;
    que[1][1]=y;
    vis[x][y]=1;
    while (head    {
        head++;
        x1=que[head][0];
        y1=que[head][1];
        for (i=0; i<4 ; i++ )
        {
            x2=x1+go[i][0];
            y2=y1+go[i][1];
            if (a[x2][y2]&&!vis[x2][y2])
            {
                tail++;
                if (x2==xx&&y2==yy)
                    return vis[x1][y1]+1;
                que[tail][0]=x2;
                que[tail][1]=y2;
                vis[x2][y2]=vis[x1][y1]+1;
            }
        }
    }
}
int dfs(int g,int x,int y,int k)   //这里确定下一步该走哪个方向。需要找到第一个可以走的方向。
{
    int i,x1,y1,gg;
    step=1;
    while (x!=xx||y!=yy)
    {
        for (i=1; i<=4 ; i++ )
        {
            gg=(g+k*i+4)%4;
            x1=x+go[gg][0];
            y1=y+go[gg][1];
            if (a[x1][y1])   //如果当前可走就break；
                break;
        }
        step++;
        g=(gg+2)%4; //由x,y向gg方向走去x1,y1，则是通过(gg+2)%4这个方向到达x1,y1的。然后循环迭代。
        x=x1;
        y=y1;
    }
}
int init()
{
    int i,j;
    char st[50];
    scanf("%d%d",&m,&n);
    memset(a,0,sizeof(a));
    for (i=1; i<=n ; i++ )
    {
        getchar();
        scanf("%s",&st);
        for (j=0; j        {
            if (st[j]!='#')
                a[i][j+1]=1;
            if (st[j]=='S')
                xs=i,ys=j+1;
            if (st[j]=='E')
                xx=i,yy=j+1;
        }
    }
}
int work()
{
    int g;
    memset(vis,0,sizeof(vis));
    least=bfs(xs,ys);
    if (xs==1)
        g=0;
    else if (ys==m)
        g=1;
    else if (xs==n)
        g=2;
    else
        g=3;
    dfs(g,xs,ys,1);
    left=step;
    dfs(g,xs,ys,-1);
    right=step;
}
int main()
{
    scanf("%d",&t);
    while (t--)
    {
        init();
        work();
        printf("%d %d %d\n",left,right,least);
    }
    return 0;
}

额，bfs和dfs写了好几个咯，该学学剪枝啦。好多东西呢，

wangs 2012-03-31 20:43 发表评论

hdu1173(水过)

wangs — Sat, 31 Mar 2012 07:57:00 GMT

我嚓，中位数，水题一个！

这个是在哪里看过的呢？？？？

wangs 2012-03-31 15:57 发表评论

hdu1172(水过)

wangs — Sat, 31 Mar 2012 07:37:00 GMT

http://acm.hdu.edu.cn/showproblem.php?pid=1172

好几天都没有写代码做题了，看书，效率好低好低的说。看SD（ACM）里在讨论各种比赛，哎哎，各种膜拜啊。ACM，水也要水一个才行。
直接枚举啊，其实这个题我觉得还是有其他方法的，得多看看：
我想写个min(s,t)求最小数的，居然写了个:
#define min(s,t) ((s=s+t),(t=s-t),(s=s-t))
哎哎，弱爆了！！！

水题水题，

wangs 2012-03-31 15:37 发表评论

poj1019(线段树)

wangs — Sat, 24 Mar 2012 15:07:00 GMT

http://user.qzone.qq.com/289065406/blog/1301527312
这个题解，挺详细，不错。

注意的就是log()和pow()函数的使用

两个都是重载函数，函数原型分别为

double log(double)

float log(float)

double pow(double , double)

float pow(float ,float)

所以当传参的类型不是double或float时，必须强制转换为其中一种类型，否则编译出错。一般建议用double

#include<stdio.h>
#include<string.h>
#include<math.h>

unsigned a[31269],s[31269];

int init()
{
    int i;
    a[1]=s[1]=1;
    for (i=2; i<31269 ; i++ )
    {
        a[i]=a[i-1]+(int)log10((double)i)+1;
        s[i]=s[i-1]+a[i];
    }
    return 0;
}

int compute(int n)
{
    int i=1,pos,len;
    while (s[i]<n)
        i++;
    pos=n-s[i-1];
    len=0;
    for (i=1; len<pos ; i++ )
        len+=(int)log10((double)i)+1;
    return (i-1)/(int)pow((double)10,len-pos)%10;
}

int main()
{
    int t,n,ans,i;
    init();
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d",&n);
        ans=compute(n);
        printf("%d\n",ans);
    }
    return 0;
}

wangs 2012-03-24 23:07 发表评论

hdu1272&&1232(并查集)

wangs — Wed, 21 Mar 2012 09:08:00 GMT

赤裸裸的并查集嘛，不过1272还真的坑爹啊，居然0 0输入也是有效的，真晕了。并查集，好东东，路径压缩不错哈！！
hdu1272(水过)：

hdu1232（水过）：

嗯，今天效率低啊，就两排序一并查集。哎，呀哦加油；

wangs 2012-03-21 17:08 发表评论

计数排序

wangs — Wed, 21 Mar 2012 03:31:00 GMT

计数排序是个好东东，有点空间换时间的感觉，不过，还是得要求输入的数不能太大，想想感觉好像是有啥离散化的方法来解决这个问题呢。哎，学的东西少了，也不知道该怎么处理。

#include<stdio.h>
#include<string.h>
#include<math.h>

int a[105],b[105],c[100005];
int main()
{
    int n,i,k;
    scanf("%d",&n);
    k=0;
    for (i=1; i<=n ; i++ )
    {
        scanf("%d",&a[i]);
        k=a[i]>k?a[i]:k;
    }
    memset(c,0,sizeof(c));
    for (i=1; i<=n ; i++ )
        c[a[i]]++;
    for (i=1; i<=k ; i++ )
        c[i]+=c[i-1];
    for (i=1; i<=n ; i++ )
    {
        b[c[a[i]]]=a[i];
        c[a[i]]--;
    }
    for (i=1; i<=n ; i++ )
        printf("%d ",b[i]);
    return 0;
}

这个是线性时间的，时间复杂度根据输入数据的大小来确定。挺好的一个思想。

wangs 2012-03-21 11:31 发表评论

Stooge排序

wangs — Wed, 21 Mar 2012 03:05:00 GMT

《算法导论》7-3看到了这个好东东，beautiful-sort，代码确实漂亮。不愧是教授啊，Howard，Fine，膜拜ing.

int stooge_sort(int a[],int s,int t)
{
    int k;
    if (a[s]>a[t])
        swap(a[s],a[t],k);
    if (s+1>=t)
        return 0;
    k=(t-s+1)/3;
    stooge_sort(a,s,t-k);
    stooge_sort(a,s+k,t);
    stooge_sort(a,s,t-k);
}

a) 证明：如果n=Length[A]，那么STOOGE-SORT(A, 1, Length[A])能正确地对输入数组A[1..n]进行排序。

循环不变式：过程STOOGE-SORT(A, i, j)被调用后，数组A中[i, j]区间内的元素是有序的。
初始化：i+1>=j时，[i, j]区间中只有一个或者两个元素，唯一的操作就是 if A[i]>A[j] then exchange A[i]<->A[j]，显然循环不变式是成立的。
保持：每一次STOOGE-SORT(A, i, j)被调用时，假设循环不变式成立。则调用STOOG-SORT(A, i, j-k)使得区间[i, j-k]有序，调用STOOG-SORT(A, i+k, j)使得区间[i+k, j]有序。因为k=(j-i+1)/3，所以区间[i, j-k]和区间[i+k, j]的重叠部分区间[i+k, j-k]的元素个数为[i, j]中元素个数的1/3，也为k个。因调用STOOG-SORT(A, i, j-k)后区间[i, j-k]有序，所以区间[i+k, j-k]中的元素应该是区间[i, j-k]中最大的k个元素，于是调用STOOG-SORT(A, i+k, j)后可以保证区间[j-k+1, j]中包含区间[i, j]中最大的k个元素并且是有序的。因此可保证在第二次调用STOOG-SORT(A, i, j-k)后区间[i, j]有序。
终止：STOOGE-SORT(A, i, Length[A])调用结束后，根据循环不变式，数组A中的元素是有序的。

b) 给出一个表达STOOGE-SORT最坏情况的运行时间的递归式，以及关于最坏情况运行时间的一个紧确的渐进（Θ记号）界。

T(n)=3T(2n/3)+Θ(1)

根据主定理：

a=3 b=3/2 f(n)=Θ(1)

故有 f(n)=O(n^log(3/2, 3-ε)) (ε>0)

所以 T(n)=Θ(n^log(3/2, 3))>Θ(n^2)

复制了大牛的文章过来，没事自己看看。

不过怎么觉得Thomas.H.Cormen等人有点讽刺讽刺这几个教授呢？？

wangs 2012-03-21 11:05 发表评论

poj3278(bfs)

wangs — Tue, 20 Mar 2012 01:53:00 GMT

http://poj.org/problem?id=3278

bfs：要注意边界条件啊，这里辉哥一直wa肯定就是这个原因啦，哈哈哈哈哈：

变量的使用也要有个好的规范才行，不然总是搞错哈。

wangs 2012-03-20 09:53 发表评论

poj2488(dfs)

wangs — Mon, 19 Mar 2012 13:16:00 GMT

http://poj.org/problem?id=2488

dfs：我晕，这个是需要按照字典序来遍历搜索和输出的！！！字典序啊字典序！！！！代码很难看，将就将就吧，有时间再改改：

改了好久好久啊，要慢慢注意这个问题咯！！

wangs 2012-03-19 21:16 发表评论

poj3126(prime+bfs)

wangs — Fri, 16 Mar 2012 20:41:00 GMT

http://poj.org/problem?id=3126

这里两天写bfs写了不少了，慢慢有点感觉啦，哈哈，队列是个好东西。从SPFA的FIFO队列到堆实现的优先级队列，应该还有还多好多吧。。。。慢慢去了解！
跟队友讨论了讨论，1000的节点觉得这个图大了点如果Floyd地话，肯定超时！想想也用不找最短路嘛，这里路径权重都是1，所以bfs啊，肯定最短路咯。

不过，写了一种方法，肯定是还有其他方法的。baidu去看看

#include<stdio.h>
#include<string.h>
#include<math.h>
int prime[1200],f[10005],map[1200][1200];
int que[1200],d[1200];
int a,b,tot;
int bfs()
{
    int head,tail,now,i,s,t;
    if (a==b)
        return 0;
    memset(d,0,sizeof(d));
    s=f[a];
    t=f[b];
    head=0;
    tail=1;
    que[1]=s;
    d[s]=1;
    while (head<tail)
    {
        head++;
        now=que[head];
        for (i=1; i<=tot ; i++ )
            if (!d[i]&&map[now][i]==1)
            {
                if (i==t)
                    return d[now];
                tail++;
                que[tail]=i;d[i]=d[now]+1;
            }
    }
}
int link(int s,int t)
{
    int i;
    i=0;
    if (s/1000!=t/1000)
        i++;
    if ((s%1000)/100!=(t%1000)/100)
        i++;
    if ((s%100)/10!=(t%100)/10)
        i++;
    if (s%10!=t%10)
        i++;
    return i;
}
int init()
{
    int i,j,k;
    memset(f,0,sizeof(f));
    tot=0;
    i=2;k=1;
    while (i<=10000)
    {
        while (f[i])    i++;
        j=i;
        while (j<=10000)
            f[j]=1,j+=i;
        if (i>1000)
            f[i]=++tot,prime[tot]=i;
    }
    tot--;
    for (i=1; i<=tot ; i++ )
        for (j=1; j<=i ; j++ )
            map[i][j]=map[j][i]=link(prime[i],prime[j]);
}
int main()
{
    int n,ans;

    init();
    scanf("%d",&n);

    while (n>0)
    {
        n--;
        scanf("%d%d",&a,&b);
        ans=bfs();
        printf("%d\n",ans);
    }
    return 0;
}

嗯，一次AC，很爽啊！！哈哈，

wangs 2012-03-17 04:41 发表评论

poj3087(模拟)

wangs — Fri, 16 Mar 2012 19:10:00 GMT

http://poj.org/problem?id=3087

说好的搜索呢？？明明就是个简单的模拟嘛，不过那个字符串处理我还真是有问题啊！！！！！

#include<stdio.h>
#include<string.h>
#include<math.h>
char s1[103],s2[103],s[205],ss[205],s0[205],p[205];
int c,ans;

int shuffle()
{
    int i;
    strcpy(p,ss);
    for (i=0;i<c ;i++ )
    {
        ss[2*i+1]=p[i];
        ss[2*i]=p[c+i];
    }
    ans++;
}
int main()
{
    int t,i,j;
    scanf("%d",&t);

    for (i=1;i<=t ;i++ )
    {
        scanf("%d",&c);
        scanf("%s%s%s",&s1,&s2,&s);
        ans=0;
        for (j=0;j<c ;j++ )
        {
            ss[j]=s1[j];
            ss[c+j]=s2[j];
        }
        ss[2*c]=0;
        shuffle();
        strcpy(s0,ss);
        if (strcmp(s,ss)==0)
        {
            printf("%d %d\n",i,ans);
        }
        else
        {
            while (1)
            {
                shuffle();
                if (strcmp(ss,s0)==0)
                {
                    ans=-1;
                    break;
                }
                if (strcmp(ss,s)==0)
                    break;
            }
            printf("%d %d\n",i,ans);
        }
    }
}

字符串处理，字符串！！！

wangs 2012-03-17 03:10 发表评论

poj3026(floodfill+prim)

wangs — Fri, 16 Mar 2012 17:29:00 GMT

http://www.cppblog.com/jh818012/articles/165674.html

这个是我sb队友写的题解，一看就发现了错误，哈哈哈，不过AC了！！！！

bfs+prim，我不懂floodfill，不过bfs还是懂的。今晚终于写了个bfs了，AC真是爽啊。哈哈哈哈哈，
悲催的数据的输入，要注意注意呀，以后涉及字符串输入的，都要小心哈！用gets()比较好哦啊

#include<stdio.h>
#include<string.h>
#include<math.h>
int x,y,tot;
int    map[2505][2505],a[10005],b[10005],p[2505],que[1000005];
int dis[2505],vis[2505];

int bfs(int s)
{
    int head,tail,i,x1,y1,now;
    memset(b,0,sizeof(b));

    que[1]=p[s];
    b[p[s]]=1;
    head=0;
    tail=1;
    while (head<tail)
    {
        head++;
        now=que[head];
        x1=(now-1)/y+1;
        y1=(now-1)%y+1;

        if (x1>1&&!b[now-y]&&a[now-y])
        {
            tail++;
            que[tail]=now-y;
            b[now-y]=b[now]+1;
        }
        if (x1<x&&!b[now+y]&&a[now+y])
        {
            tail++;
            que[tail]=now+y;
            b[now+y]=b[now]+1;
        }
        if (y1>1&&!b[now-1]&&a[now-1])
        {
            tail++;
            que[tail]=now-1;
            b[now-1]=b[now]+1;
        }
        if (y1<y&&!b[now+1]&&a[now+1])
        {
            tail++;
            que[tail]=now+1;
            b[now+1]=b[now]+1;
        }
    }
    for (i=1; i<=tot ; i++ )
        map[s][i]=b[p[i]]-1;
}

int prim()
{
    int i,j,sum,min,minj;
    for (i=1; i<=tot ; i++ )
    {
        dis[i]=100000000;
        vis[i]=1;
    }
    sum=0;
    dis[1]=0;
    for (i=1; i<=tot ; i++ )
    {
        min=100000000;
        for (j=1; j<=tot ; j++ )
            if (dis[j]<min&&vis[j])
            {
                min=dis[j];
                minj=j;
            }
        sum+=min;
        vis[minj]=0;
        for (j=1; j<=tot ; j++ )
            if (vis[j]&&map[minj][j]<dis[j])
                dis[j]=map[minj][j];
    }
    return sum;
}
int init()
{
    int i,j;
    char ch[55];
    scanf("%d%d",&y,&x);
        tot=0;
        gets(ch);
        for (i=1; i<=x ; i++ )
        {
            gets(ch);
            for (j=1; j<=y ; j++ )
            {
                if (ch[j-1]=='#')
                    a[i*y-y+j]=0;
                else if (ch[j-1]==' ')
                    a[i*y-y+j]=1;
                else
                {
                    tot++;
                    p[tot]=i*y-y+j;
                    a[i*y-y+j]=1;
                }
            }
        }
}
int work()
{
    int i,ans;
    for (i=1; i<=tot ; i++ )
        bfs(i);
    ans=prim();
    printf("%d\n",ans);
}
int main()
{
    int n;
    scanf("%d",&n);
    while (n>0)
    {
        n--;
        init();
        work();
    }
    return 0;
}

要开始注意代码风格了，我的代码太难看啦！！！

wangs 2012-03-17 01:29 发表评论

poj1273(网络流)

wangs — Tue, 13 Mar 2012 10:53:00 GMT

http://poj.org/problem?id=1273

赤裸裸的网络最大流问题：刚刚学的EK：

#include<stdio.h>
#include<string.h>
#include<math.h>
int map[205][205],pre[205],vis[205],que[200005];
int m,n,ans;

int min(int s,int t)
{
    if (s<=t)
        return s;
    return t;
}
int bfs(int s,int t)
{
    int head,tail,i,u;
    memset(vis,1,sizeof(vis));
    head=1;tail=1;
    vis[s]=0;
    que[1]=s;
    while (head<=tail)
    {
        u=que[head++];
        for (i=1;i<=n ;i++ )
            if (vis[i]&&map[u][i])
            {
                pre[i]=u;
                if (i==t)
                    return 1;
                que[++tail]=i;
                vis[i]=0;
            }
    }
    return 0;
}
int dfs(int s,int t)
{
    int i;
    for (i=1;i<=n ;i++ )
        if (vis[i]&&map[s][i])
        {
            pre[i]=s;
            if (i==t)
                return 1;
            vis[i]=0;
            if (!dfs(i,t))
                vis[i]=1;
            else
                return 1;
        }
    return 0;
}
int end(int s,int t)
{
    int i,sum=1000000000;
    for (i=t;i!=s ;i=pre[i] )
        sum=min(sum,map[pre[i]][i]);
    for (i=t;i!=s ;i=pre[i] )
        map[pre[i]][i]-=sum,map[i][pre[i]]+=sum;
    ans+=sum;
}
int main()
{
    int i,j,x,y,z;
    while (scanf("%d%d",&m,&n)==2)
    {
        for (i=1;i<=n ;i++ )
            for (j=1;j<=n ;j++ )
                map[i][j]=0;

        for (i=1;i<=m ;i++ )
        {
                scanf("%d%d%d",&x,&y,&z);
                map[x][y]+=z;
        }

        ans=0;

        memset(vis,1,sizeof(vis));
        vis[1]=0;
        while (bfs(1,n))
        {
            end(1,n);memset(vis,1,sizeof(vis));vis[1]=0;
        }
        printf("%d\n",ans);
    }
    return 0;
}

第一次wa了，看了discuss才知道可能有重边！！！又是一个活生生的例子啊！！！哦耶，网络问题，开始啦。

wangs 2012-03-13 18:53 发表评论

hdu1052(贪心)

wangs — Mon, 12 Mar 2012 14:11:00 GMT

http://acm.hdu.edu.cn/showproblem.php?pid=1052

尼玛的贪心算法：

#include<stdio.h>

int qsort(int x[],int s,int t)
{
    int i,j,mid,tmp;
    i=s;
    j=t;
    mid=x[(i+j)/2];
    while (i<=j)
    {
        while (x[i]>mid)    i++;
        while (x[j]<mid)    j--;
        if (i<=j)
        {
            tmp=x[i];
            x[i]=x[j];
            x[j]=tmp;
            i++;
            j--;
        }
    }
    if (s<j)    qsort(x,s,j);
    if (i<t)    qsort(x,i,t);
}
int main()
{
    int n,i,i1,i2,j1,j2,ans,a[1003],b[1003];
    while (scanf("%d",&n)==1&&n!=0)
    {
        for (i=1; i<=n; i++)
            scanf("%d",&a[i]);
        qsort(a,1,n);
        for (i=1; i<=n; i++)
            scanf("%d",&b[i]);
        qsort(b,1,n);   //尼玛，这里我复制过来的，qsort(a,1,b);，，wa了我数十次啊！！！！！！

        ans=0;
        i1=1;
        j1=n;
        i2=1;
        j2=n;
        while (i1<=j1)
        {
            if (a[j1]>b[j2])
            {
                ans++;
                j1--;j2--;
                continue;
            }
            else
                if (a[j1]<b[j2])
                {
                    ans--;
                    j1--;i2++;
                    continue;
                }
            if (a[i1]>b[i2])
            {
                ans++;
                i1++;i2++;
                continue;
            }
            else
                if (a[i1]<b[i2])
                {
                    ans--;
                    j1--;i2++;
                    continue;
                }
                else
                    if (a[j1]<b[i2])
                    {
                        ans--;
                        j1--;i2++;
                    }
                    else
                    {
                        j1--;i2++;
                    }
        }
        printf("%d\n",ans*200);
    }
    return 0;
}

wangs 2012-03-12 22:11 发表评论

ural-1049(质因子分解)

wangs — Sun, 11 Mar 2012 03:45:00 GMT

http://acm.timus.ru/problem.aspx?space=1&num=1049

质因子分解：题意明显，注意如果全部相乘会很大，所以得一个一个质因子分解然后做乘法，一边乘最好一边模10,以免溢出：

#include<stdio.h>
#include<string.h>
#include<math.h>
int prime[5000],f[10010],tot;
int main()
{
    int i,j,t,ans;
    memset(f,0,sizeof(f));
    f[1]=1;
    i=1;tot=0;
    while (i<10000)
    {
        while (f[i]&&i<10000)    i++;
        t=i;
        tot++;
        prime[tot]=i;
        while (t<10000)
        {
            f[t]=1;
            t=t+i;
        }
    }

    tot--;

    memset(f,0,sizeof(f));
    for (i=1;i<=10;i++)
    {
        scanf("%d",&t);
        j=1;
        while (t>1&&j<=tot)
        {
            while (t%prime[j]==0)
            {
                t=t/prime[j];
                f[j]++;
            }
            j++;
        }
    }
    ans=1;
    for (i=1;i<=tot;i++)
        if (f[i])
            ans=(ans*(f[i]+1));
    printf("%d\n",ans);
    return 0;
}

质因子分解当然筛法嘛，没得说。smy sb写了好几个程序我就只给他改了一点点就ac了，不写程序不行啊，不敲代码的弱爆了！

wangs 2012-03-11 11:45 发表评论

ural-1244(背包dp)

wangs — Sun, 11 Mar 2012 03:40:00 GMT

http://acm.timus.ru/problem.aspx?space=1&num=1244

dp，0-1背包问题：注意题意要看懂，话说我wa了不知道多少次，看了题解才知道原来是要求剩余重量的背包问题！！！记录路径的dp：

#include<stdio.h>
#include<string.h>
#include<math.h>
int tot,n,a[105],g[100005],p[1000005],q[105];
int main()
{
    int i,j,flag,sum;
    while (scanf("%d%d",&tot,&n)==2)
    {
        memset(g,0,sizeof(g));
        memset(p,0,sizeof(p));
        sum=0;
        for (i=1; i<=n ; i++ )
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        tot=sum-tot;
        if (tot<0)
        {
            printf("0\n");
            continue;
        }
        g[0]=1;
        for (i=1; i<=n; i++)
        {
            for (j=tot-a[i]; j>=0; j--)
                if (g[j])
                {
                    if (!g[j+a[i]])
                        p[j+a[i]]=i;
                    g[j+a[i]]+=g[j];
                }
        }

        if (g[tot]==0)
            printf("0\n");
        else if (g[tot]>1)
            printf("-1\n");
        else
        {
            j=0;
            for (i=n; i>=1 ; i-- )
                if (p[tot]==i)
                {
                    q[++j]=i;
                    tot=tot-a[i];
                }
            for (i=j; i>1 ; i-- )
                printf("%d ",q[i]);
            printf("%d\n",q[1]);
        }
    }
    return 0;
}

这些个经验还是要好好积累啊！！！题意看懂有点难，

wangs 2012-03-11 11:40 发表评论

ural-1306（堆-优先级序列）

wangs — Sun, 11 Mar 2012 03:35:00 GMT

http://acm.timus.ru/problem.aspx?space=1&num=1306

堆的优先级序列：寻找中位数,这个问题250000个数，如果排序nlogn,肯定不会超时，不过这里内存只有1024K，最多也就只能保存25000个int，而且堆调用显然会TLE，所以得寻找另外的办法。堆，这里可以借用它的优先级序列。因为只用寻找中位数，则保留前面一半或者后面一半都行，应该分别使用大堆和小堆。这里我用的是大堆。开辟130000的数组，先读入n/2+1个数，建堆。则最前面的数肯定是当前最大的数。以后读入的数如果比这个大或者等于，那么肯定排序应该在后面一半，如果小，则当前最大的数肯定是后面一半的，替换之，并且维护好这个堆。这个问题也在nlogn的时间内解决的，也不会TLE：

#include<stdio.h>
#include<string.h>
#include<math.h>
int heap[130000];
int heapify(int i) //过滤下去
{
    int n,l,r,large,tmp;
    n=heap[0];
    l=2*i;r=l+1;
    if (l<=n&&heap[l]>heap[i])
        large=l;
    else
        large=i;
    if (r<=n&&heap[r]>heap[large])
        large=r;
    if (large!=i)
    {
        tmp=heap[i];heap[i]=heap[large];heap[large]=tmp;
        heapify(large);
    }
}
int main()
{
    int n,i,t,max;
    double ans;
    while (scanf("%d",&n)==1)
    {
        t=n/2+1;
        for (i=1;i<=t;i++)
            scanf("%d",&heap[i]);
        heap[0]=t;
        for (i=t/2;i>=1;i--)
            heapify(i);
        for (i=t+1;i<=n;i++)
        {
            scanf("%d",&t);
            if (t<heap[1])
            {
                heap[1]=t;
                heapify(1);
            }
        }
        if (n%2==1)
            ans=heap[1]*2.0;
        else
        {
            max=heap[2]>heap[3]?heap[2]:heap[3];
            ans=heap[1]+max*1.0;
        }
        printf("%.1lf\n",ans/2.0);
    }
    return 0;
}

wangs 2012-03-11 11:35 发表评论

poj2728(最优比率生成树)

wangs — Fri, 09 Mar 2012 16:35:00 GMT

http://poj.org/problem?id=2728

最优比率生成树：这个都可以直接模板来使用了。0-1分数规划，参数搜索，Dinkelbach算法也很好写：

#include<stdio.h>
#include<string.h>
#include<math.h>
#define eps 1e-6
#define inf 1e8

int n,vis[1005],p[1005];
double d[1005][1005],h[1005][1005],g[1005][1005],dis[1005],dt,ht,zl;

double max(double s,double t)
{
    if (s>t)
        return s;
    else
        return t;
}
void prim(double L)//这里是找最小生成树，
{
    int i,j,minj;
    double min;
    dt=ht=zl=0;

    for (i=1; i<=n ; i++ )
        for (j=1; j<=n ; j++ )
            g[i][j]=h[i][j]-L*d[i][j];

    for (i=1; i<=n ; i++ )
        dis[i]=inf,vis[i]=1;
    dis[1]=0.0;
    p[1]=1;
    for (i=1; i<=n ; i++ )
    {
        min=inf;
        for (j=1; j<=n ; j++ )
            if (vis[j]&&min>dis[j])
            {
                min=dis[j];
                minj=j;
            }
        vis[minj]=0;
        dt+=d[minj][p[minj]];
        ht+=h[minj][p[minj]];
        zl+=dis[minj];
        for (j=1; j<=n ; j++ )
            if (vis[j]&&dis[j]>g[minj][j])
            {
                dis[j]=g[minj][j];
                p[j]=minj;
            }
    }
}
int main()
{
    int i,j;
    double maxx,L;
    float x[1005],y[1005],z[1005];
    while (scanf("%d",&n)==1&&n!=0)
    {
        for (i=1; i<=n ; i++ )
            scanf("%f%f%f",&x[i],&y[i],&z[i]);
        maxx=0;
        for (i=1; i<=n ; i++ )
            for (j=1; j<=n ; j++ )
            {
                d[i][j]=sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));
                h[i][j]=fabs(z[i]-z[j]);
                maxx=max(maxx,h[i][j]);
            }
        L=n*maxx;  //这个边界条件还可以收敛一些，
        while (prim(L),fabs(zl)>eps)    L=ht/dt;
        printf("%.3lf\n",L);
    }
    return 0;
}

擦，这个在poj上一下就ac了，hdu上wa，应该是内存的问题吧。不管了，又学会了一个算法，值！叫啥？Dinkelbach算法，迭代下去，挺好写的，算法证明也好理解。那个啥二分法，有时间得写写。0-1分数规划（0-1fractional programming），参数搜索(parametric search)都是好东西呀。

还有好多好多啥prim的堆优化，线形时间复杂度的好多东东不懂，加油啦。

wangs 2012-03-10 00:35 发表评论

hdu1017(枚举-水题)

wangs — Wed, 07 Mar 2012 09:31:00 GMT

http://acm.hdu.edu.cn/showproblem.php?pid=1017

枚举，a:2--->n-2,b:a+1...n-1;验证（a,b）:(a*a+b*b+m)%(a*b)即可！！！
水题一个，注意输出格式：

#include<stdio.h>
#include<string.h>
#include<math.h>

int main()
{
    int N,n,m,a,b,i,t,ans,flag=0;
    scanf("%d",&N);
    for (i=1;i<=N ;i++ )
    {
        if (flag)
            printf("\n");
        flag=1;t=0;
        while (scanf("%d%d",&n,&m)&&(n!=0)||(m!=0))
        {
            t++;
            ans=0;
            for (a=1;a<n ;a++ )
                for (b=a+1;b<n ;b++ )
                {
                    if ((a*a+b*b+m)%(a*b)==0)
                    {
                        ans++;
                    }
                }
            printf("Case %d: %d\n",t,ans);
        }
    }
    return 0;
}

做做水题，练习输入输出格式还是有用的。呵呵，

wangs 2012-03-07 17:31 发表评论

hdu1013（模拟&数论）

wangs — Wed, 07 Mar 2012 09:09:00 GMT

http://acm.hdu.edu.cn/showproblem.php?pid=1013

这个题模拟也可以AC，刚开始我也是模拟AC的。不过看了百度看了大牛的博客，感谢大牛，知道了还有数论这回事。

n=0 1 2 3 4 5 6 7 8 9 10 11 12 13 ......... 100 101 102 103 ....
roots=0 1 2 3 4 5 6 7 8 9 1 2 3 4 .......1 2 3 4....
原来是以1.....9为循环节的。想想也是，每次增加1，那么层层迭代下来，最终当ans<10的时候也是每次增加了1。如此，可以归纳出
roots=(n-1)%9+1

注意输入的数字很大需要字符串读入，求和得n:

#include<stdio.h>
#include<string.h>
#include<math.h>

int main()
{
    int i,n,tmp;
    char a[1003];
    while (scanf("%s",&a)&&a[0]!='0')
    {
        n=0;
        for (i=0;i<strlen(a); i++)
        {
            n+=a[i]-48;
        }
        printf("%d\n",(n-1)%9+1);
    }
    return 0;
}

啊，要多研究研究啊，本能只是止步于表面东西，大牛，Orz。。。

wangs 2012-03-07 17:09 发表评论

统计数字

wangs — Tue, 06 Mar 2012 15:42:00 GMT

统计1到n，所有数字中，0,1,....,9出现的次数。

额，这个问题简单。

#include<stdio.h>
int main()
{
    int n,i,q,r,t,now,a[10];
    while (scanf("%d",&n)==1)
    {
        for (i=0;i<=9;i++)
            a[i]=0;
        t=10;
        while (n/t!=0)
        {
            r=n%t;
            q=n/t;
            now=r*10/t;
            for (i=0;i<=9;i++)
                a[i]=a[i]+q*t/10;
            for    (i=0;i<now;i++)
                a[i]=a[i]+t/10;
            a[now]=a[now]+r%(t/10)+1;
            t=t*10;
        }
        now=n*10/t;r=n;
        for (i=1;i<now;i++)
            a[i]=a[i]+t/10;
        a[now]=a[now]+r%(t/10)+1;
        if (a[0]>0)    a[0]--;
        for (i=0;i<=9;i++)
            printf("%d\n",a[i]);
    }
}

编程啊，要养成好习惯啊，先设计好算法，再上机敲代码才行啊。不然，全乱了。

wangs 2012-03-06 23:42 发表评论

hdu1874(最短路)

wangs — Tue, 06 Mar 2012 15:40:00 GMT

http://acm.hdu.edu.cn/showproblem.php?pid=1874

最短路径问题，经典的Dijsktra嘛。Floyd解决多源点问题，这里是单源点就行。因为可能有重边，而且数据范围也不大，就选用邻接矩阵来储存了。
d[i]表示当前i所找到的最短路径，f[i]记录集合：

#include<stdio.h>
    int n,m,maxx=100000000,q[203][203];
int dijsktra(int s,int t)
{
    int d[203],f[203],i,j,min,minj;
    for (i=1;i<=n;i++)
    {
        d[i]=maxx;
        f[i]=1;
    }
    d[s]=0;   //这里害我wa了很多次。切记
    for (i=1;i<=n;i++)
    {
        min=maxx;
        for (j=1;j<=n;j++)
            if (f[j]&&d[j]<min)
            {
                min=d[j];
                minj=j;
            }
        if (minj==t)
            return min;
        f[minj]=0;
        for (j=1;j<=n;j++)
            if (f[j]&&d[j]>d[minj]+q[minj][j])
            {
                d[j]=d[minj]+q[minj][j];
            }
    }
    return -1;
}
int main()
{
    int i,j,s,t,k,ans,a,b,c;
    while (scanf("%d%d",&n,&m)==2)
    {
        for (i=1;i<=n;i++)
        {
            for (j=1;j<=n;j++)
                q[i][j]=maxx;
            q[i][i]=0;
        }
        for (i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if (c<q[a+1][b+1])
            {
                q[a+1][b+1]=c;
                q[b+1][a+1]=c;
            }
        }
        scanf("%d%d",&s,&t);
        ans=dijsktra(s+1,t+1);
        printf("%d\n",ans);
    }
}

无语了，这个wa了不知道多少次。结果就是d[s]习惯性地打成d[1]了，这个，要注意呀！重边也需要考虑的哦。

wangs 2012-03-06 23:40 发表评论

poj1328(贪心)

wangs — Sun, 04 Mar 2012 13:09:00 GMT

http://poj.org/problem?id=1328

贪心。从左到右建立雷达，要尽量多地覆盖岛屿。以岛屿的圆心d为半径的圆与x轴有或者没有交点。如果存在没有交点的则不能实现！都存在交点的话，对于第i个岛屿计算出左右交点的x坐标保存在a[i],b[i]里。对a[]排序，然后一次从左到右找雷达。初始right=b[1]为当前最右边的左标，则对于下一个考虑岛屿i,如果a[i]>right则当前需要建立的雷达不能覆盖它，需要以此开始建立下一个雷达;否则，如果b[i]别忘了最后需要建立雷达，即ans++:

#include<stdio.h>
    double a[1003],b[1003];
int qsort(int s,int t)
{
    int i,j;
    double mid,tmp;
    i=s;j=t;mid=a[(i+j)/2];
    while (i<=j)
    {
        while (a[i]<mid)    i++;
        while (a[j]>mid)    j--;
        if (i<=j)
        {
            tmp=a[i];a[i]=a[j];a[j]=tmp;
            tmp=b[i];b[i]=b[j];b[j]=tmp;
            i++;
            j--;
        }
    }
    if (s<j)    qsort(s,j);
    if (i<t)    qsort(i,t);
}
int main()
{
    int n,i,x,y,d,ans,flag,t;
    double right,xx;
    scanf("%d%d",&n,&d);

    t=0;
    while (n!=0||d!=0)
    {
        flag=0;t++;
        for (i=1;i<=n;i++)
        {
            scanf("%d%d",&x,&y);
            if (y>d)
                flag=1;
            xx=sqrt(d*d-y*y);
            a[i]=x-xx;b[i]=x+xx;
        }

        if (flag)
        {
            printf("Case %d: -1\n",t);
            scanf("%d%d",&n,&d);
            continue;
        }

        qsort(1,n);
        ans=0;

        right=b[1];i=2;
        while (i<=n)
        {
            if (a[i]>right)
            {
                ans++;right=b[i];
            }
            if (b[i]<right)
                    right=b[i];
            i++;
        }
        ans++;
        printf("Case %d: %d\n",t,ans);
        scanf("%d%d",&n,&d);
    }
}

这个题，提交了无数次才ac，我嚓OLE！数据读入需要注意啊，还有实型数要注意注意哦。

wangs 2012-03-04 21:09 发表评论

poj1258（最小生成树）

wangs — Sat, 03 Mar 2012 16:49:00 GMT

http://poj.org/problem?id=1258

最小生成树。Prim或者Kruskal。

以下Prim算法，输入矩阵：

#include<stdio.h>
    int  d[103][103],flag[103],lowcost[103],link[103],a[103],b[103];
int main()
{
    int n,i,j,min,minj,tot;
    while (scanf("%d",&n)==1)
    {
        for (i=1;i<=n;i++)
            for (j=1;j<=n;j++)
                scanf("%d",&d[i][j]);

        for (i=1;i<=n;i++)
        {
            flag[i]=1;
            lowcost[i]=1000000;
            link[i]=1;
        }
        for (i=1;i<=n;i++)
            if (d[1][i])
                lowcost[i]=d[1][i];
        flag[1]=0;tot=0;
        for (i=2;i<=n;i++)
            {
                min=1000000;
                for (j=2;j<=n;j++)
                    if (flag[j]&&min>lowcost[j])
                    {
                        min=lowcost[j];
                        minj=j;
                    }
                flag[minj]=0;tot+=min;
                for (j=2;j<=n;j++)
                    if (flag[j]&&d[minj][j]&&lowcost[j]>d[minj][j])
                    {
                        lowcost[j]=d[minj][j];
                        link[j]=minj;
                    }
            }

        printf("%d\n",tot);
    }
}

哦哦，a[],b[]用来记录生成树的边的。这里没有用上。啊，n^2,这个复杂度不行啊，得学学高级的方法才行啊。

wangs 2012-03-04 00:49 发表评论

poj1753（枚举）

wangs — Sat, 03 Mar 2012 16:30:00 GMT

http://poj.org/problem?id=1753

枚举。这个和poj2965一样嘛，不用多说：

#include<stdio.h>
    int a[17],b[17],t[17];
int check()
{
    int i,sum=0;
    for (i=1;i<=16;i++)
        sum+=b[i];
    if (sum==16||sum==0)
        return 1;
    return 0;
}
int turn(int s)
{
    int x,y;
    x=(s-1)/4+1;y=(s-1)%4+1;
    if (x>1)
        b[s-4]=1-b[s-4];
    if (x<4)
        b[s+4]=1-b[s+4];
    if (y>1)
        b[s-1]=1-b[s-1];
    if (y<4)
        b[s+1]=1-b[s+1];
    b[s]=1-b[s];
}
int main()
{
    int i,j,step,ans;
    char ch;
    for (i=1;i<=4;i++)
    {
        for (j=1;j<=4;j++)
        {
            scanf("%c",&ch);
            if (ch=='w')
                a[i*4-4+j]=1;
            else
                a[i*4-4+j]=0;
        }
        scanf("%c",&ch);
    }
    ans=17;
    for (t[1]=0;t[1]<=1;t[1]++)
    for (t[2]=0;t[2]<=1;t[2]++)
    for (t[3]=0;t[3]<=1;t[3]++)
    for (t[4]=0;t[4]<=1;t[4]++)
    for (t[5]=0;t[5]<=1;t[5]++)
    for (t[6]=0;t[6]<=1;t[6]++)
    for (t[7]=0;t[7]<=1;t[7]++)
    for (t[8]=0;t[8]<=1;t[8]++)
    for (t[9]=0;t[9]<=1;t[9]++)
    for (t[10]=0;t[10]<=1;t[10]++)
    for (t[11]=0;t[11]<=1;t[11]++)
    for (t[12]=0;t[12]<=1;t[12]++)
    for (t[13]=0;t[13]<=1;t[13]++)
    for (t[14]=0;t[14]<=1;t[14]++)
    for (t[15]=0;t[15]<=1;t[15]++)
    for (t[16]=0;t[16]<=1;t[16]++)
    {
        for (i=1;i<=16;i++)
            b[i]=a[i];
        for (i=1;i<=16;i++)
            if (t[i])
                turn(i);
        if (check())
        {
            step=0;
            for (i=1;i<=16;i++)
                    step=step+t[i];
            if (step<ans)
                ans=step;
        }
    }
    if (ans<=16)
        printf("%d\n",ans);
     else
         printf("Impossible");
}

多做点枚举的题目总是好的，枚举枚举，不一定是搜索哦。

wangs 2012-03-04 00:30 发表评论

URAL-1204（欧几里德扩展）

wangs — Sat, 03 Mar 2012 16:01:00 GMT

http://acm.timus.ru/problem.aspx?space=1&num=1204

数论，欧几里德扩展。x*x-x=pq*a*b，其中a*b=n，为质数。可化解得x*(x-1)=ap*qb。则可知x=ap,(x-1)=qb或者x=qb,(x-1)=ap。则ap-qb=1或者qb-ap=1;因为gcd(a,b)=1,则extended_euclid可以求得p，q。解之：

#include<stdio.h>
int x,y,p[400000],prime[40000];
int ex_euclid(int a,int b)
{
    int c,tmp;
    if (b==0)
    {
        x=1;y=0;
        return a;
    }
    c=ex_euclid(b,a%b);
    tmp=x;x=y;y=tmp-a/b*y;
    return c;
}
int main()
{
    int i,j,a,b,n,now,t;
    memset(p,0,sizeof(p));
    now=2;t=0;
    while (now<400000)
    {
        t++;prime[t]=now;
        i=now;
        while (i<400000)
        {
            p[i]=1;
            i+=now;
        }
        while (p[now])
            now++;
    }
    scanf("%d",&n);
    while (scanf("%d",&n)==1)
    {
        i=1;
        while (i<t&&n%prime[i])
            i++;
         a=prime[i];
         b=n/a;
         ex_euclid(a,b);
         if ((a*x+n)%n<(y*b+n)%n)
             printf("%d %d %d %d\n",0,1,(a*x+n)%n,(y*b+n)%n);
         else
             printf("%d %d %d %d\n",0,1,(y*b+n)%n,(a*x+n)%n);
    }
}

数学公式，慢慢研究化解，总有办法的。嘿嘿，
为什么timus上提交的时候我的两个大数组没有放在前面而发生了

Crash (stack overflow)呢？怎么回事啊？？？

wangs 2012-03-04 00:01 发表评论

poj2965（枚举）

wangs — Sat, 03 Mar 2012 15:33:00 GMT

http://poj.org/problem?id=2965

枚举。刚开始拿到就bfs，结果第一组数据就跑了好几秒！16^16啊，吃不消的。原来每个位置肯定最多就只翻动一次嘛，根据这个可枚举了，翻或者不翻，0，1嘛。2^16,能搞定了。
我还是喜欢用一维数组来表示棋盘状态，i-->1到16分别对应格子(（i-1）/4+1,(i-1)A%4+1),a[i]里，0表示关1表示开，t[i]里0表示不翻转1表示翻转。OK,16重循环枚举吧，应该是写过最多的循环了吧。嘿嘿：

#include<stdio.h>
    int a[17],b[17],t[17];
int check()
{
    int i,sum=0;
    for (i=1;i<=16;i++)
        sum+=b[i];
    if (sum==16)
        return 1;
    return 0;
}
int turn(int s)
{
    int i,x,y;
    x=(s-1)/4+1;y=(s-1)%4+1;
    for (i=1;i<=4;i++)
    {
        b[x*4-4+i]=1-b[x*4-4+i];
        b[y]=1-b[y];
        y=y+4;
    }
    b[s]=1-b[s];
}
int main()
{
    int i,j,step;
    char ch;
    for (i=1;i<=4;i++)
    {
        for (j=1;j<=4;j++)
        {
            scanf("%c",&ch);
            if (ch=='-')
                a[i*4-4+j]=1;
            else
                a[i*4-4+j]=0;
        }
        scanf("%c",&ch);
    }
    for (t[1]=0;t[1]<=1;t[1]++)
    for (t[2]=0;t[2]<=1;t[2]++)
    for (t[3]=0;t[3]<=1;t[3]++)
    for (t[4]=0;t[4]<=1;t[4]++)
    for (t[5]=0;t[5]<=1;t[5]++)
    for (t[6]=0;t[6]<=1;t[6]++)
    for (t[7]=0;t[7]<=1;t[7]++)
    for (t[8]=0;t[8]<=1;t[8]++)
    for (t[9]=0;t[9]<=1;t[9]++)
    for (t[10]=0;t[10]<=1;t[10]++)
    for (t[11]=0;t[11]<=1;t[11]++)
    for (t[12]=0;t[12]<=1;t[12]++)
    for (t[13]=0;t[13]<=1;t[13]++)
    for (t[14]=0;t[14]<=1;t[14]++)
    for (t[15]=0;t[15]<=1;t[15]++)
    for (t[16]=0;t[16]<=1;t[16]++)
    {
        for (i=1;i<=16;i++)
            b[i]=a[i];
        for (i=1;i<=16;i++)
            if (t[i])
                turn(i);
        if (check())
        {
            step=0;
            for (i=1;i<=16;i++)
                if (t[i])
                    step++;
            printf("%d\n",step);
            for (i=1;i<=16;i++)
                if (t[i])
                    printf("%d %d\n",(i-1)/4+1,(i-1)%4+1);
            return 0;
        }
    }
}

那个行和列都要翻转，则那个要翻转两次，所以别忘了最后还要翻转啊！
不过，还有数学方程来解的，我得看看去。。。。

wangs 2012-03-03 23:33 发表评论