divide conquer

Merge  Merge_sort实现源码：

#include <iostream>
#include <cstdio>
#define inf 1e9
using namespace std;

void merge(int A[],int p,int q,int r)
{
    int i,j;
    int n1=q-p+1;
    int n2=r-q;
    int L[n1+2],R[n2+2];
    for(i=1;i<=n1;i++)
        L[i]=A[p+i-1];
    for(i=1;i<=n2;i++)
        R[i]=A[q+i];
    L[n1+1]=inf;
    R[n2+1]=inf;
    i=1;j=1;
    for(int k=p;k<=r;k++)
    {
        if(L[i]<=R[j])
        {
            A[k]=L[i];
            i++;
        }
        else
        {
            A[k]=R[j];
            j++;
        }
    }
}

void merge_sort(int A[],int p,int r)
{
    int q;
    if(p<r)
    {
        q=(p+r)/2;
        merge_sort(A,p,q);
        merge_sort(A,q+1,r);
        merge(A,p,q,r);
    }
}

int main()
{
    int A[20];
    for(int i=1;i<=10;i++)
        scanf("%d",&A[i]);
    merge_sort(A,1,10);
    for(int i=1;i<=10;i++)
        printf("%3d",A[i]);
    puts("");
    return 0;
}

分治与递归：把一个难以解决的问题分解到可以解决的范畴

讲得不错：

1.子问题的解

2.规模增大的状态方程

3.递归的设计

快速乘法取模：a*b%c=(a%c)*b)%c

快速幂取模: a^b%c用下列方法：

考虑：(a^b)%c   b=p(n)*2^n+p(n-1)*2^n-1+....+p(0)*1

对于:p(i)=0的部分不用考虑,对于p(i)=1的部分

a^(2^i)%c=((a^(2^(i-1))%c*(a^(2^(i-1))))%c然后分治递归。

uva,374

参考：1111     2222   

#include <iostream>
#include <cstdio>

using namespace std;

int dfs(int b,int p,int m)
{
    if(p==0) return 1;
    if(p==1) return b;
    int a=dfs(b,p>>1,m);
    a=a*a%m;
    if(p%2)
        return a*b%m;
    return a;
}

int main()
{
    int b,p,m;
    while(~scanf("%d%d%d",&b,&p,&m))
    {
        printf("%d
",dfs(b%m,p,m));
    }
}

#include <iostream>
#include <cstdio>

using namespace std;

int dfs(int b,int p,int m)
{
    int pow=1;
    int tmp=b;
    while(p)
    {
        if(p&0x1)
            pow=pow*tmp%m;
        tmp=tmp*tmp%m;
        p>>=1;
    }
    return pow;
}


int main()
{
    int b,p,m;
    while(~scanf("%d%d%d",&b,&p,&m))
    {
        printf("%d
",dfs(b%m,p,m));
    }
    return 0;
}

uva,11129

题意：求一个序列，不含有长度大于等于3的等差子列。

解法：每次把奇偶拆分，然后依次分治拆分，

例如: 0 1 2 3 4

奇数项：0 2 4    偶数项： 1 3

奇数项：0 4   偶数项：2       奇数项：1  偶数项：3

然后整个序列就是所求的序列了。

因为：当分到每个奇数项有两个元素，每个偶数项有一个元素，这样组合每三个元素都不为等差子列。

通俗一点：每分出的两个序列中：奇数项的元素之差和偶数项元素之差为2*k，而两个序列的对应奇数项和偶数项之差为2*k+1.(k=1,2,3..)

还不懂的话：就是看整个序列的性质：   a1 a2 a3 a4 a5 a6

　　　　　　　　　　　　　　　　　　a1 a3 a5   a2 a4 a6   左边序列的任意两个元素或一个元素和右边的一个元素或两个元素不可能构成等差。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>

using namespace std;
const int maxn=10005;

int ans[maxn],tmp[maxn];
int n;

void solve(int l,int r)
{
    int i,j;
    if(l==r) return;
    memcpy(tmp,ans,sizeof(ans));  //把ans的值赋给tmp
    for(i=l,j=l;i<=r;i+=2,j++)
        ans[j]=tmp[i];    //奇数项拆分
    for(i=l+1;i<=r;i+=2,j++)
        ans[j]=tmp[i];    //偶数项拆分
    solve(l,(l+r)/2);   //分治，左边
    solve((l+r)/2+1,r);//右边
}

void output()
{
    printf("%d:",n);
    for(int i=0;i<n;i++)
        printf(" %d",ans[i]);
    puts("");
}

int main()
{
    while(scanf("%d",&n),n)
    {
        for(int i=0;i<n;i++)
            ans[i]=i;  //初始化
        solve(0,n-1);
        output();
    }
    return 0;
}

uva,10245   平面上的分治《最近点对》

借此题复习了c＋＋容器

最近点对，分治法求lgn的效率解决每个区域的最小值，然后求两个区域之间的最近点对。

可以把所有的在矩形区域的点对都求出来，其实可以只找7个点就可以了：其实就是高是ans宽为2*ans的一个矩形中最多有8个点，所以只用找一个点的7个点

if(l==r)要加上，要不然每次单个的点都要走一遍，会超时。

最后的直接min1<=10000也可以。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;
const int maxn=10005;

int a[maxn];
struct node
{
    double x,y;
}p[maxn];

bool cmpx(node a,node b)
{
    return a.x<b.x;
}

bool cmpy(int& a,int& b)
{
    return p[a].y<p[b].y;
}

double dist(node a,node b)
{
    double dx=a.x-b.x;
    double dy=a.y-b.y;
    return sqrt(dx*dx+dy*dy);
}

double minx(double a,double b)
{
    return a<b?a:b;
}

double cloest_pair(int l,int r)
{
    if(l==r)
        return 0xffffffff;//貌似不加这一点会超时
    if(l+1==r)
        return dist(p[l],p[r]);
    if(l+2==r)
        return minx(dist(p[l],p[r]),minx(dist(p[l],p[l+1]),dist(p[l+1],p[r])));
    int mid=(l+r)>>1;
    double ans=minx(cloest_pair(l,mid),cloest_pair(mid+1,r));
    int cnt=0;
    for(int i=l;i<=r;i++)
    {
        if(fabs(p[i].x-p[mid].x)<=ans)
            a[cnt++]=i;//只是纪录一下每个在矩形范围的引用
    }
    sort(a,a+cnt,cmpy);
    for(int i=0;i<cnt;i++)
    {
        int k=(i+7)>cnt?cnt:(i+7);//找七个点就可以了
        for(int j=i+1;j<k && p[a[j]].y-p[a[i]].y<=ans;j++)
            ans=minx(ans,dist(p[a[i]],p[a[j]]));//注意是a[i]
    }
    return ans;
}

int main()
{
    int n;
    while(scanf("%d",&n),n)
    {
        for(int i=0;i<n;i++)
            scanf("%lf%lf",&p[i].x,&p[i].y);
        sort(p,p+n,cmpx);
        double min1=cloest_pair(0,n-1);
        if(min1-10000<=1e-9)//对以后所有的趋近于，都用一种渐进趋势
            printf("%.4lf
",min1);
        else
            printf("INFINITY
");
            
    }
    return 0;
}

树分治：点分治，边分治，

点分治：找重心然后递归分治求解

边分治：分出两块，比较简单易懂但是时间复杂度较高

Poj,1741

求出树中两个点之间的边长距离不超过k的顶点对数

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>

using namespace std;
const int maxn=10005;
struct edge
{
    int to;
    int length;
};

int N,K;
vector<edge> G[maxn];
bool centroid[maxn];
int subtree_size[maxn];
int ans;


int compute_subtree_size(int v,int p)
{
    int c=1;
    for(int i=0;i<G[v].size();i++)
    {
        int w=G[v][i].to;
        if(w==p || centroid[w])
            continue;
        c+=compute_subtree_size(G[v][i].to,v);
    }
    subtree_size[v]=c;
    return c;
}

pair<int,int> search_centroid(int v,int p,int t)
{
    pair<int,int> res=make_pair(INT_MAX,-1);
    int s=1,m=0;
    for(int i=0;i<G[v].size();i++)
    {
        int w=G[v][i].to;
        if(w==p || centroid[w])
            continue;
        res=min(res,search_centroid(w,v,t));
        m=max(m,subtree_size[w]);
        s+=subtree_size[w];
    }
    m=max(m,t-s);
    res=min(res,make_pair(m,v));
    return res;
}

void enumerate_paths(int v,int p,int d,vector<int>& ds)
{
    ds.push_back(d);
    for(int i=0;i<G[v].size();i++)
    {
        int w=G[v][i].to;
        if(w==p || centroid[w])
            continue;
        enumerate_paths(w,v,d+G[v][i].length,ds);
    }
}

int count_pairs(vector<int>& ds)
{
    int res=0;
    sort(ds.begin(),ds.end());
    int j=ds.size();
    for(int i=0;i<ds.size();i++)
    {
        while(j>0 && ds[i]+ds[j-1]>K)
            --j;
        res+=j-(j>i?1:0);
    }
    return res/2;
}

void solve_subproblem(int v)
{
    compute_subtree_size(v,-1);
    int s=search_centroid(v,-1,subtree_size[v]).second;
    centroid[s]=true;
    
    for(int i=0;i<G[v].size();i++)
    {
        if(centroid[G[v][i].to])
            continue;
        solve_subproblem(G[s][i].to);
    }
    
    vector<int> ds;
    ds.push_back(0);
    for(int i=0;i<G[s].size();i++)
    {
        if(centroid[G[s][i].to])
            continue;
        vector<int> tds;
        enumerate_paths(G[s][i].to,s,G[s][i].length,tds);
        
        ans-=count_pairs(tds);
        ds.insert(ds.end(),tds.begin(),tds.end());
    }
    
    ans+=count_pairs(ds);
    centroid[s]=false;
}
int main()
{
    scanf("%d%d",&N,&K);
    int a,b,l;
    for(int i=0;i<4;i++)
    {
        scanf("%d%d%d",&a,&b,&l);
        edge now;
        now.to=b;
        now.length=l;
        G[a].push_back(now);
        now.to=a;
        G[b].push_back(now);
    }
    ans=0;
    solve_subproblem(1);
    printf("%d
",ans);
    return 0;
}

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#define MP make_pair
using namespace std;

void read(int& x) {
    x = 0;
    char c = ' ';
    while(c < '0' || c > '9') c = getchar();
    while('0' <= c && c <= '9') {
        x = x * 10 + c - '0';
        c = getchar();
    }
}

typedef pair<int, int> PII;
const int maxn = 10000 + 10;
const int INF = 0x3f3f3f3f;

struct Edge
{
    int v, w, nxt;
    Edge() {}
    Edge(int v, int w, int nxt): v(v), w(w), nxt(nxt) {}
};

int n, k, ans;
vector<int> d, d2;
bool del[maxn];

int ecnt, head[maxn];
Edge edges[maxn * 2];

void AddEdge(int u, int v, int w) {
    edges[ecnt] = Edge(v, w, head[u]);
    head[u] = ecnt++;
}

int fa[maxn], sz[maxn];

void dfs(int u) {
    sz[u] = 1;
    for(int i = head[u]; ~i; i = edges[i].nxt) {
        int v = edges[i].v;
        if(v == fa[u] || del[v]) continue;
        fa[v] = u;
        dfs(v);
        sz[u] += sz[v];
    }
}

PII findCenter(int u, int t) {
    PII ans(INF, -1);
    int m = 0;
    for(int i = head[u]; ~i; i = edges[i].nxt) {
        int v = edges[i].v;
        if(v == fa[u] || del[v]) continue;
        ans = min(ans, findCenter(v, t));
        m = max(m, sz[v]);
    }
    m = max(m, t - sz[u]);
    ans = min(ans, MP(m, u));
    return ans;
}

void getDist(int u, int p, int dist, vector<int>& d) {
    d.push_back(dist);
    for(int i = head[u]; ~i; i = edges[i].nxt) {
        int v = edges[i].v, w = edges[i].w;
        if(v == p || del[v]) continue;
        getDist(v, u, dist + w, d);
    }
}

int cntPiars(vector<int>& d) {
    int ans = 0;
    sort(d.begin(), d.end());
    int j = d.size();
    for(int i = 0; i < d.size(); i++) {
        while(j && d[i] + d[j-1] > k) j--;
        ans += j - (j > i ? 1 : 0);
    }
    return ans;
}

void solve(int u) {
    fa[u] = 0;
    dfs(u);
    int s = findCenter(u, sz[u]).second;
    del[s] = true;
    
    for(int i = head[u]; ~i; i = edges[i].nxt) {
        int v = edges[i].v;
        if(del[v]) continue;
        solve(v);
    }

    d.clear();
    d.push_back(0);
    for(int i = head[s]; ~i; i = edges[i].nxt) {
        int v = edges[i].v, w = edges[i].w;
        if(del[v]) continue;
        d2.clear();
        getDist(v, s, w, d2);
        ans -= cntPiars(d2);
        d.insert(d.begin(), d2.begin(), d2.end());
    }

    ans += cntPiars(d);
    del[s] = false;
}

int main()
{
    while(scanf("%d", &n) == 1 && n) {
        ecnt = 0;
        memset(head, -1, sizeof(head));
        for(int u = 1; u <= n; u++) {
            int v, w;
            for(read(v); v; read(v)) {
                read(w);
                AddEdge(u, v, w);
                AddEdge(v, u, w);
            }
        }

        for(read(k); k; read(k)) {
            ans = 0;
            solve(1);
            int pre = ans;
            ans = 0;
            k--;
            solve(1);
            printf("%s
", pre - ans > 0 ? "AYE" : "NAY");
        }
        printf(".
");
    }

    return 0;
}

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <cmath>

#define maxn 11111
#define maxm 55555

using namespace std;

struct edge   //建边
{
    int v,w,next;
}E[maxm];

int head[maxn],e;  //head[]来表示一个点的所有子树
int vis[maxn],n,k,ans,root,num;  //vis用来找重心

void init()
{
    e=0;
    memset(head,-1,sizeof(head));
}

void add(int u,int v,int w)
{
    E[e].v=v;  //建边，然后纪录所有的子树节点
    E[e].w=w;
    E[e].next=head[u];
    head[u]=e++;
}

int mi,dis[maxn],size[maxn],mx[maxn];

void dfssize(int u,int fa)   //求出每棵子树的节点数
{ 
    size[u]=1;
    mx[u]=0;
    for(int i=head[u];i!=-1;i=E[i].next)
    {
        int v=E[i].v;
        if(v!=fa && !vis[v])  //为什么不更新vis了，我一开始不知道这个算法的时候是这么想的，因为下次还要访问。
        {
            dfssize(v,u);
            size[u]+=size[v];
            if(size[v]>mx[u])//求出一个节点的子树中最大子树
                mx[u]=size[v];
        }
    }
}

void dfsroot(int r,int u,int fa)
{
    if(size[r]-size[u]>mx[u])  //如果删除该顶点后，得到最大子树
        mx[u]=size[r]-size[u];
    if(mx[u]<mi)//得到的最大子树的节点最小
        mi=mx[u],root=u;
    for(int i=head[u];i!=-1;i=E[i].next)
    {
        int v=E[i].v;
        if(v!=fa && !vis[v])
            dfsroot(r,v,u);
    }
}

void dfsdis(int u,int d,int fa)//求出所有的点到重心的距离。
{
    dis[num++]=d;
    for(int i=head[u];i!=-1;i=E[i].next)
    {
        int v=E[i].v;
        if(v!=fa && !vis[v])
            dfsdis(v,d+E[i].w,u);
    }
    
}

int calc(int u,int d)
{
    int ret=0;
    num=0;
    dfsdis(u,d,0);
    sort(dis,dis+num);//排序后的精髓确保时间复杂度最小
    int i=0,j=num-1;
    while(i<j)
    {
        if(dis[i]+dis[j]<k) i++;
        else if(dis[i]+dis[j]>k) j--;
        else
        {
            if(dis[i]==dis[j]) //i-j 的任意两点满足情况。一个等差和
            {
                ret+=(j-i)*(j-i+1)/2;
                break;
            }
            int st=i,ed=j;
            while(dis[i]==dis[st]) st++;  
            while(dis[j]==dis[ed]) ed--;
            ret+=(st-i)*(j-ed);
            i=st,j=ed;
        }
    }
    return ret;
}

void dfs(int u)
{
    mi=n;
    dfssize(u,0);
    dfsroot(u,u,0);
    ans+=calc(root,0);  //所有满足情况的对
    vis[root]=1;
    for(int i=head[root];i!=-1;i=E[i].next)
    {
        int v=E[i].v;
        if(!vis[v])
        {
            ans-=calc(v,E[i].w); //删除重复计算的。
            dfs(v);
        }
    }
    
}
void solve()
{
    memset(vis,0,sizeof(vis));
    ans=0;
    dfs(1);
    if(ans>0)
        printf("AYE
");
    else
        printf("NAY
");
}

int main()
{
    while(scanf("%d",&n),n)
    {
        init();
        int v,w;
        for(int i=1;i<=n;i++)
        {
            while(scanf("%d",&v),v)
            {
                scanf("%d",&w);
                add(i,v,w);
                add(v,i,w);
            }
        }
        
        while(scanf("%d",&k),k)
            solve();
        printf(".
");
    }
    return 0;
}