csu 2014 summer trainning day 1 哈希

POJ 1200

题意：给定串s，串中不同字符数nc，所求子串长度n，求长度为n的不同的子串的个数

分析：处理长度很短的字符串哈希，数据保证可以无冲突存储下来，利用hash思想快速查询以前便利的结果，关键在于优化搜索。

code：

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <set>
using namespace std;

int c[270];
bool Hash[13000000];
char s[1000100];
int d,l;
void init(int len){
   memset(c,0,sizeof(c));
   memset(Hash,0,sizeof(Hash));
   int cnt=0;
   for(int i=0;i<len;i++){
        if (c[s[i]]==0){
            c[s[i]]=++cnt;
        }
        if (cnt==d) break;
   }
   return ;
}
void solve(int len){
    int ans=0;
    int v=0;
    int p=1;
    for(int i=1;i<l;i++) p*=d;
    for(int i=0;i<l;i++){
        v=v*d+c[s[i]];
    }
    Hash[v]=true;
    ans++;
    for(int i=l;i<len;i++){
        v=(v-c[s[i-l]]*p)*d+c[s[i]];
        if (!Hash[v]){
            ans++;
            Hash[v]=true;
        }
    }
    printf("%d
",ans);
    return ;
}
int main(){
    while(~scanf("%d%d",&l,&d)){
        scanf("%s",s);
        int len=strlen(s);
        init(len);
        solve(len);
    }
    return 0;
}

POJ 1635

题意：给定一棵有根树的最小表示，即便利的结果，远离树根表示0，靠近树根表示1，给定两串不同便得到的01序列，判断两棵树是否是同构的。

分析：1、判断树同构的方法，统计F(x)，表示子节点数为x的节点的个数，若两个树的F(x)在定义域内是完全相等的，则两棵树同构。

        2、分析01串：在纸上举几个例子，就能得到规律。便利的结果是满足栈的结构的，所以处理出每个节点在串中出现（一个0，一个1）的两个位置，

那么这两个位置对应的节点的子节点的个数就是，字符串中这两个位置夹的0（或1）的个数。预处理O(n),统计O(n)

code:

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <set>
#include <stack>
using namespace std;

int t;
char s1[3010],s2[3010];
int px1[3010],py1[3010];
int px2[3010],py2[3010];
int num1[3010],num2[3010];
int cnt1,cnt2,len;
int S[3010],p;//手动开的栈
bool check(){
    memset(num1,0,sizeof(num1));
    memset(num2,0,sizeof(num2));
    for(int i=1;i<=cnt1;i++){
        int x=px1[i];
        int y=py1[i];
        int c=0;
        for(int i=x+1;i<y;i++){
            if (s1[i]=='0') c++;
        }
        num1[c]++;
    }
    for(int i=1;i<=cnt2;i++){
        int x=px2[i];
        int y=py2[i];
        int c=0;
        for(int i=x+1;i<y;i++){
            if (s2[i]=='0') c++;
        }
        num2[c]++;
    }
    for(int i=0;i<=cnt2;i++){
        if (num1[i]!=num2[i]) return false;
    }
    return true;
}
void solve(){
    len=strlen(s1);
    if (len!=(int)strlen(s2)){
        puts("different");
        return ;
    }
    cnt1=0;p=0;
    for(int i=0;i<len;i++){
        if(s1[i]=='0'){
            S[++p]=++cnt1;
            px1[cnt1]=i;
        }
        if (s1[i]=='1'){
            py1[S[p--]]=i;
        }
    }
////    for(int i=1;i<=cnt1;i++){
////        cout<<px1[i]<<" "<<py1[i]<<endl;
////    }
    cnt2=0;p=0;
    for(int i=0;i<len;i++){
        if(s2[i]=='0'){
            S[++p]=++cnt2;
            px2[cnt2]=i;
        }
        if (s2[i]=='1'){
            py2[S[p--]]=i;
        }
    }
    if (cnt1!=cnt2) {
        puts("different");
        return ;
    }
    if (check()){
        puts("same");
    }else puts("different");

    return ;
}
int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%s",s1);
        scanf("%s",s2);
        solve();
    }
    return 0;
}

POJ 1971

题意：给定1000个二维坐标节点，判断这些节点能构成的平行四边形有多少个。坐标范围<=1000000000

分析：数学知识是必要的，不然很难想到很快的搜索办法（反正开始时我没有），即平行四边形的两对对顶点的的中点是重合的。

那么，若存在两个重合的中点，那么这两条边交叉起来能构成一个平行四边形。

       那么我们O(n^2)枚举任意两个点，处理出他们的中点（处理成整数，不除2）。

      得到n^2/2个中点的我们现在要能快速找找到对于每种中点有几个是相等的。这道题不使用hash，排序后，成段扫描处理即可，当然，Hash更快。

#include <iostream>
#include <queue>
#include <string.h>
#include <stdio.h>
#include <algorithm>
using namespace std;

int t,n;
int x[1100],y[1100];
struct N{
    int x,y;
    bool operator <(const N&X)const{
        if (x==X.x) return y<X.y;
        else return x<X.x;
    }
    bool operator==(const N&X)const{
        return x==X.x&&y==X.y;
    }

}Ps[1100000];
void print(int cnt){
        for(int i=0;i<cnt;i++){
            cout<<"("<<Ps[i].x<<","<<Ps[i].y<<")"<<endl;
        }
    }
int cnt;
int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        for(int i=0;i<n;i++){
            scanf("%d%d",&x[i],&y[i]);
        }
        cnt=0;
        for(int i=0;i<n-1;i++){
            for(int j=i+1;j<n;j++){
                Ps[cnt++]=(N){x[i]+x[j],y[i]+y[j]};
            }
        }
        sort(Ps,Ps+cnt);
        long long ans=0;
        int k=1;
        for(int i=1;i<cnt;i++){
            if (Ps[i]==Ps[i-1]){
                k++;
            }else{
                ans=ans+(long long)k*(k-1)/2;
                k=1;
            }
        }
        printf("%I64d
",ans);
    }
    return 0;
}

POJ 2002

题意：给定1000个二维坐标节点，判断它们能构成多少个正方形。

分析：1、不造为什么用上一题类似的方法会错？？？当然，要满足两个垂直一个重合

         2、首先所有点(X^2+Y^2)%Mod哈希存一遍code

         3、用到数学知识：

Point A=(Point){x[i]-y[i]+y[j],y[i]+x[i]-x[j]};
Point B=(Point){x[j]-y[i]+y[j],y[j]+x[i]-x[j]};
Point C=(Point){x[i]+y[i]-y[j],y[i]-x[i]+x[j]};
Point D=(Point){x[j]+y[i]-y[j],y[j]-x[i]+x[j]};
    枚举两点，公式求出另外两点，Hash查找这些点是否在图上，统计出个数，用组合数学即可处理
code：

#include <iostream>
#include <queue>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#define Mod 49999
using namespace std;
struct Point{
    int x,y;
    int k;
    bool operator==(const Point&X){
        return x==X.x&&y==X.y;
    }
};
vector<Point>G[Mod+100];

void init(){
    for(int i=0;i<Mod+10;i++) G[i].clear();
}

int Hash(Point P){
    return (P.x*P.x+P.y*P.y)%Mod;
}

int findx(Point P){
    int ha=Hash(P);
    int i;
    for(i=0;i<G[ha].size();i++){
        if (G[ha][i]==P) break;
    }
    if (i==G[ha].size()) return 0;
    return G[ha][i].k;
}
void Insert(Point P){
    int ha=Hash(P);
    int i;
    for(i=0;i<G[ha].size();i++){
        if (G[ha][i]==P) {
            G[ha][i].k++;
            break;
        }
    }
    if (i==G[ha].size()){
        G[ha].push_back((Point){P.x,P.y,1});
    }
    return ;
}

int n;
int x[1100],y[1100];
int main(){
    while(~scanf("%d",&n)&&n){
        init();
        for(int i=0;i<n;i++){
            scanf("%d%d",&x[i],&y[i]);
            Insert((Point){x[i],y[i],0});
        }
        int ans=0;
        for(int i=0;i<n-1;i++){
            for(int j=i+1;j<n;j++){
                Point A=(Point){x[i]-y[i]+y[j],y[i]+x[i]-x[j]};
                Point B=(Point){x[j]-y[i]+y[j],y[j]+x[i]-x[j]};
                Point C=(Point){x[i]+y[i]-y[j],y[i]-x[i]+x[j]};
                Point D=(Point){x[j]+y[i]-y[j],y[j]-x[i]+x[j]};
                int k1=findx(C);
                int k2=findx(D);
                int k3=findx(A);
                int k4=findx(B);
                ans+=(k1*k2)+(k3*k4);
            }
        }
        ans=ans/4;
        printf("%d
",ans);
    }
    return 0;
}

POJ 2549

题意：给定一集合S，给定集合中的所有数，统计A+B+C=D的个数，A、B、C、D皆取自S，且是各不相同的元素。集合的元素的个数<=1000

分析: 类似白书上的中途相遇法，等式可以这样看，A+B=D-C，两两枚举，Hash存储，再两两枚举D，A，统计即可。注意存的时候，要保留A、B，

      因为A、B、C、D要不相同，所以要判断。

code：

#include <iostream>
#include <queue>
#include <string.h>
#include <stdio.h>
#include <algorithm>
#include <vector>
#define Mod 49999

using namespace std;
struct Node{
    int add,a1,a2;
};
vector<Node>G[Mod+100];
void init(){
    for(int i=0;i<Mod+10;i++) G[i].clear();
}
void Insert(int k,int b1,int b2){
    int key=k;
    while(key<0) key=key+Mod;
    key=key%Mod;
    int i;
    for(i=0;i<G[key].size();i++){
        int add=G[key][i].add;
        int a1=G[key][i].a1;
        int a2=G[key][i].a2;
        if (add == k && (a1+a2==b1+b2) && (a1-a2==b1-b2)) break;
    }
    if (i==G[key].size()) G[key].push_back(Node{k,b1,b2});
    return ;
}
bool Search(int d,int c){
    int key=d-c;
    while(key<0) key=key+Mod;
    key=key%Mod;
    int i;
    for(i=0;i<G[key].size();i++){
        int add=G[key][i].add;
        int a1=G[key][i].a1;
        int a2=G[key][i].a2;
        if (add==d-c && a1!=d && a2!=d && a1!=c && a2!=c) return true;
    }
    return false;
}
int a[1010];
int n;
int main(){
    while(~scanf("%d",&n)&&n){
        init();
        for(int i=0;i<n;i++) scanf("%d",&a[i]);
        for(int i=0;i<n-1;i++){
            for(int j=i+1;j<n;j++){
                Insert(a[i]+a[j],a[i],a[j]);
            }
        }
        int m=-536870913;
        for(int i=0;i<n-1;i++){
            for(int j=i+1;j<n;j++){
                if (Search(a[i],a[j])) m=max(m,a[i]);
                if (Search(a[j],a[i])) m=max(m,a[j]);
            }
        }
        if (m==-536870913) puts("no solution");
        else printf("%d
",m);
    }
    return 0;
}

列出一些Hash要用到的素数：

prime=997，  prime=1999 ， prime=7993 ， prime=9973， prime=29989， prime=49999，prime=99991