总结一

                        10月30日——11月4日

本周放弃在VirtualJudge上的刷题，正式开始了算法竞赛入门经典（第二版）的学习，本周的学习目标是第六章-数据结构基础的内容，主要是对于树和图的练习。

第一题：小球落下（Dropping Balls，UVa 679）
先贴出错误代码

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

int swi[1<<22];

int main()
{
    long long a,b,c;
    while(scanf("%lld %lld",&a,&b)==2)
    {
        memset(swi,0,sizeof(swi));
        b=b-1;
        while(b--)
        {
            for(long long i=1;i<1<<(a-1);)
            {
                int j=i;
                if(swi[i]==0) i=2*i;
                else i=2*i+1;
                swi[j]=~swi[j];
            }
        }
        for(long long i=1;i<1<<(a-1);)
        {
            if(swi[i]==0) i=2*i;
            else i=2*i+1;
            c=i;
        }
        printf("%lld\n",c);
    }
}

本题犯的错误是直接模拟所有过程，并没有加以分析，导致计算次数过多（Runtime Error）注意练习动手打代码前准备，不要做无用功。

贴上正确代码：

#include<cstdio>
using namespace std;

int main()
{
    int D,I;
    int n;
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d %d",&D,&I);
        int ans=1;
        for(int i=1;i<D;i++)
        {
            if(I%2)
            {
                ans=2*ans;
                I=(I+1)/2;
            }
            else
            {
                ans=2*ans+1;
                I=I/2;
            }
        }
        printf("%d\n",ans);
    }
}

第二题：树的层次遍历（Tree on the level,Duke 1993,UVa 122）

本题在实现的时候遇到了很多困难，参看了很多代码，但是都理解并不是很深刻，在此就不贴出代码了，希望通过后面学习，能返回来顺利AC本题。

第三题：树（Tree， UVa 548）

本题非常有意思，通过中序遍历和后序遍历构造出树，然后一次dfs遍历，能求出最短路径。
先贴代码：

#include <cstdio>

#define maxn 10100
using namespace std;
int in[maxn],pos[maxn];
int min1,ans;

struct tree
{
    int v;
    tree *lch,*rch;
}*root;

tree* build(int n, int* in, int* pos)
{
    int i;
    tree* node = new tree;
    if(n<=0) return NULL;
    for(i=0;in[i]!=pos[n-1];i++);
    node->v=in[i];
    node->lch=build(i,in,pos);
    node->rch=build(n-i-1,in+i+1,pos+i);
    return node;
}

void dfs(tree *tr,int sum)
{
    if(tr==NULL) return;
    sum=sum+tr->v;
    if(tr->lch==NULL && tr->rch==NULL)
    {
        if(sum<min1)
        {
            ans=tr->v;
            min1=sum;
        }
    }
    else
    {
        if(tr->lch!=NULL) dfs(tr->lch,sum);
        if(tr->rch!=NULL) dfs(tr->rch,sum);
    }
}
int main()
{
    char ch;
    while(scanf("%d%c",&in[0],&ch)!=EOF)
    {
        int n=1;
        for(int i=1;ch!='\n';i++)
        {
            scanf("%d%c",&in[i],&ch);
            n++;
        }
        ch = ' ';
        for(int i=0;ch!='\n';i++)
        {
            scanf("%d%c",&pos[i],&ch);
        }
        min1=1000001;
        root=build(n,in,pos);
        dfs(root,0);
        printf("%d\n",ans);
    }
    return 0;
}

本题代码并不是很完美（主要是不美观）书上给的代码并不是特别懂，需要再勤于练习。对于本题输入过程中数字+空格的处理，此处贴的代码我认为很有技巧，值得学习，书中用了stringstream方法，对于我还不是很熟悉。

第四题：天平（Not so Mobile,UVa 839）
本题在书中注明：本题极为重要，请读者在继续阅读之前确保完全理解了下面的程序。所以花费了过多时间在反复推演的过程中，代码还未能实现。

第五题：四分树（Quadtree, UVa 297）
此题也极为有意思，注意的点也打上了注释。贴代码：

#include <stdio.h>
#include <cstring>

const int maxn=1034;
const int len=32;
char s[maxn];
int buf[maxn][maxn],cnt;

void draw(const char* s,int &p,int r,int c,int w)
{
    char ch=s[p++];
    if(ch=='p')
    {
        draw(s,p,r,c+w/2,w/2);
        draw(s,p,r,c,w/2);
        draw(s,p,r+w/2,c,w/2);
        draw(s,p,r+w/2,c+w/2,w/2);
    }
    else if(ch=='f')//题意！！！重复部分只能算一部分
    {
        for(int i=r;i<r+w;i++)
            for(int j=c;j<c+w;j++)
            if(buf[i][j]==0)  //同理，第一个图有的第二个图就不用加了
        {
            buf[i][j]=1;
            cnt++;
        }
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        memset(buf,0,sizeof(buf));
        cnt=0;
        for(int i=0;i<2;i++)
        {
            scanf("%s",s);
            int p=0;
            draw(s,p,0,0,len); //注意这个魔性的坐标系建立
        }
        printf("%d\n",cnt);
    }
    return 0;
}

此后就是关于图的知识，主要是DFS，BFS，拓扑排序，欧拉回路。很遗憾，没能在此之前完全做完。
下面贴出几个写过的DFS和BFS的代码。

第六题：Lake Counting（POJ 2386）
目的就是找连通块。分别使用了DFS的递归，DFS的栈，BFS来解题。本题极为不美观。

#include <stdio.h>
#include <queue>
#include <stack>
#include <string.h>
#include <vector>
#include <iterator>
#include <iostream>
using namespace std;
char m[105][105];

void dfs(int i,int j)
{
    m[i][j]='.';

    if(m[i-1][j+1]=='W') dfs(i-1,j+1);
    if(m[i][j+1]=='W') dfs(i,j+1);
    if(m[i+1][j+1]=='W') dfs(i+1,j+1);
    if(m[i-1][j]=='W') dfs(i-1,j);
    if(m[i+1][j]=='W') dfs(i+1,j);
    if(m[i-1][j-1]=='W') dfs(i-1,j-1);
    if(m[i+1][j-1]=='W') dfs(i+1,j-1);
    if(m[i][j-1]=='W') dfs(i,j-1);
}

typedef struct node
{
    int x;
    int y;
}a;

void dfsstack(int x,int y)
{
    stack<node> S;
    node a;
    a.x=x;
    a.y=y;

    S.push(a);
    m[x][y]='.';
    while(!S.empty())
    {
        node a=S.top();
        S.pop();
        for(int i=-1;i<2;i++)
        {
            for(int j=-1;j<2;j++)
            {
                if(m[a.x+i][a.y+j]=='W')
                {
                    node temp;
                    temp.x=a.x+i;
                    temp.y=a.y+j;
                    m[temp.x][temp.y]='.';
                    S.push(temp);
                }
            }
        }
    }
}

/*

void bfs(int x,int y)
{
    queue<node> Q;
    node a;
    a.x=x;
    a.y=y;

    Q.push(a);
    m[x][y]='.';
    while(!Q.empty())
    {
        node temp1=Q.front();
        //printf("1");
        Q.pop();
        for(int i=-1;i<2;i++)
        {
            for(int j=-1;j<2;j++)
            {
                if(m[temp1.x+i][temp1.y+j]=='W')
                {
                    node temp;
                    temp.x=temp1.x+i;
                    temp.y=temp1.y+j;
                    Q.push(temp);
                    m[temp1.x+i][temp1.y+j]='.';
                }
            }
        }
    }
    //printf("\n");
}
*/
int main(void)
{
    int N,M;
    int ans=0;
    scanf("%d %d",&N,&M);
    for(int i=0;i<M+2;i++)
    {
        m[0][i]='X';
        m[N+1][i]='X';
    }
    for(int i=0;i<N+2;i++)
    {
        m[i][0]='X';
        m[i][M+1]='X';
    }


    for(int i=1;i<N+1;i++)
    {
        getchar();
        for(int j=1;j<M+1;j++)
        {
            scanf("%c",&m[i][j]);
        }

    }
    for(int i=1;i<N+1;i++)
    {
        for(int j=1;j<M+1;j++)
        {
            if(m[i][j]=='W')
            {
                dfsstack(i,j);
                ans++;
            }
        }
    }
    printf("%d\n",ans);
}

本题在最开始读入数据的之后，选择使用加上“围墙”的方法来防止搜索跑出，其实也可以用一个if语句来实现（大于等于最小值，小于等于最大值）。

还有一题未贴出。

本周还同时进行了C++的STL的学习，不过还未应用于实际问题，只掌握了基本操作。

下周完成本周余下程序，同时下周完成当前周任务的80%左右即可，主要要将时间花在问题分析和代码实现上。