Other_模板

1.Kmp

int next[2005];
int lena;
int lenb;

void set_naxt()//子串的next数组
{
    int i=0,j=-1;
    next[0]=-1;
    while(i<lenb)
    {
        if(j==-1||b[i]==b[j])
        {
            i++; j++;
            next[i]=j;
        }
        else
        j=next[j];
    }
}

int kmp()
{
    int i=0,j=0;
    set_naxt();
    while(i<lena)
    {
        if(j==-1||a[i]==b[j])
        {
            i++;j++;
        }
        else
        j=next[j];
        if(j==lenb)
        return i-j+1;
    }
    return -1;
}

2.归并排序

void mergesort(int l,int r)  
{  
    int i,j,k,m;  
    if(l<r)  
    {  
        m=(r+l)>>1;  
        mergesort(l,m);  
        mergesort(m+1,r);  
        k=l;  
        for(i=l,j=m+1; i<=m&&j<=r;)  
        {  
            if(a[i]>a[j])  
            {  
                b[k++]=a[j++];
		//cont+=m-(i-1);//相当于线性交换了这么多次  
            }  
            else b[k++]=a[i++];  
        }  
        while(i<=m)b[k++]=a[i++];  
        while(j<=r)b[k++]=a[j++];  
        for(i=l; i<=r; i++)a[i]=b[i];  
    }  
}  

3.快速排序

void quicksort(int l,int r)
{
    int i,j,tmp,t;
    if(l>r)return ;
    tmp=a[l];i=l,j=r;
    while(i!=j)
    {
        while(a[j]>=tmp&&i<j)j--;
        while(a[i]<=tmp&&i<j)i++;
        if(i<j)
        {
            t=a[i];a[i]=a[j];a[j]=t;
        }
    }
    a[l]=a[i];
    a[i]=tmp;
    quicksort(l,i-1);
    quicksort(i+1,r);
}

4.set排序

#include<stdio.h>  
#include<string.h>  
#include<iostream>  
#include<set>  
#include<string>  
using namespace std;  
set<string >s;  
int main()  
{  
    string a;  
    while(getline(cin,a))  
    {  
        for(int i=0; i<a.size(); i++)  
        {  
            string tmp;  
            if(!isalpha(a[i]))continue;  
            while(isalpha(a[i]))  
            {  
                if(a[i]>='A'&&a[i]<='Z')  
                tmp+=a[i]+32;  
                else tmp+=a[i];  
                i++;  
            }  
            s.insert(tmp);  
        }  
    }  
    for(set<string>::iterator it=s.begin(); it!=s.end(); it++)  
    {  
        cout<<*it<<endl;  
    }  
}  

5.Hash&&Hashmap

void Hash(char s[],ll len){
    h[0]=0;x[0]=1;
    for(ll i=1;i<=len;i++){
        x[i]=x[i-1]*29;
        h[i]=h[i-1]+x[i]*(s[i]-'a');
    }
}

bool judge(ll l,ll r,ll l2,ll r2){
    if(r-l != r2-l2) return false;
    if( (h[r]-h[l-1])*(x[l2-l]) == (h[r2]-h[l2-1]) )
        return true;
    return false;
}

const int maxn=100000;  
const int hashh=1000007;  

struct hashmap
{
    ll a[maxn];
    int head[hash];
    int next[maxn];
    int size;
    void init()
    {
        memset(head,-1,sizeof(head));
        size=0;
    }
    bool find(ll val)
    {
        int tmp=(val%hash+hash)%hash;
        for(int i=head[tmp];i!=-1;i=next[i])
        {
            if(val==a[i])return true;
        }
        return false;
    }
    void add(ll val)
    {
        int tmp=(val%hash+hash)%hash;
        if(find(val))return ;
        a[size]=val;
        next[size]=head[tmp];//令next指向-1、
        head[tmp]=size++;
    }
}h1,h2;

6.矩阵快速幂

#include<stdio.h>  
#include<iostream>  
#include<string.h>  
using namespace std;  
#define mod 10000  
typedef struct Matrix  
{  
    int mat[2][2];  
}matrix;  
matrix A,B;  
Matrix matrix_mul(matrix a,matrix b)
{  
    matrix c;  
    memset(c.mat,0,sizeof(c.mat));  
    int i,j,k;  
    for(int i=0;i<2;i++)  
    {  
        for(int j=0;j<2;j++)  
        {  
            for(int k=0;k<2;k++)  
            {  
                c.mat[i][j]+=a.mat[i][k]*b.mat[k][j];  
                c.mat[i][j]%=mod;  
            }  
        }  
    }  
    return c;  
}  
Matrix matrix_quick_power(matrix a,int k)
{  
    matrix b;  
    memset(b.mat,0,sizeof(b.mat));  
    for(int i=0;i<2;i++)  
    b.mat[i][i]=1;//单位矩阵b  
    while(k)  
    {  
        if(k%2==1)  
        {  
            b=matrix_mul(a,b);  
            k-=1;  
        }  
        else  
        {  
            a=matrix_mul(a,a);  
            k/=2;  
        }  
    }  
    return b;  
}  

矩阵快速幂+黑科技优化矩阵相乘

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
#define ll __int64
ll mod=1000000007;
ll n,m;
typedef struct Matrix
{
    ll mat[101][101];
}matrix;
matrix A,B;
Matrix matrix_mul(matrix a,matrix b)
{
    matrix c;
    memset(c.mat,0,sizeof(c.mat));
    int i,j,k;
    for(int i=0;i<n;i++)
    {
        for(int k=0;k<n;k++)
        {
            if(a.mat[i][k]==0)continue;
            for(int j=0;j<n;j++)
            {
                c.mat[i][j]=c.mat[i][j]+(a.mat[i][k]*b.mat[k][j])%mod;
                c.mat[i][j]%=mod;
            }
        }
    }
    return c;
}
Matrix matrix_quick_power(matrix a,ll k)//矩阵快速幂0.0
{
    matrix b;
    memset(b.mat,0,sizeof(b.mat));
    for(int i=0;i<n;i++)
    b.mat[i][i]=1;//单位矩阵b
    while(k)
    {
        if(k%2==1)
        {
            b=matrix_mul(a,b);
            k-=1;
        }
        else
        {
            a=matrix_mul(a,a);
            k/=2;
        }
    }
    return b;
}
int main()
{
    while(cin>>n>>m)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                scanf("%I64d",&A.mat[i][j]);
            }
        }
        B=matrix_quick_power(A,m);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                printf("%I64d ",B.mat[i][j]%mod);
            }
            printf("\n");
        }
    }
}

7.优先队列

struct zuobiao
{
    int x,y,output;
    friend bool operator <(zuobiao a,zuobiao b)
    {
        return a.output>b.output;
    }
}now,nex;
    priority_queue<zuobiao>s;
struct cmp{
    bool operator ()(int &a,int &b){
        return a>b;//最小值优先
    }
};       
priority_queue<int,vector<int>,cmp>s;//最小值优先

8.读入优化

#include<stdio.h>
#include<string.h>
using namespace std;
int Scan()
{
	int res = 0, ch, flag = 0;

	if((ch = getchar()) == '-')				//判断正负
		flag = 1;

	else if(ch >= '0' && ch <= '9')			//得到完整的数
		res = ch - '0';
	while((ch = getchar()) >= '0' && ch <= '9' )
		res = res * 10 + ch - '0';

	return flag ? -res : res;
}
int main()
{
    int n=Scan();
    printf("%d\n",n);
}

9.进制数取模

int judge(date &b)
{
    int tmp=0;
    for(int i=0;i<b.len;i++)
    {
        tmp=(tmp*c+b.a[i])%n;
    }
    return tmp;
}

10.从Claris巨巨那里学来的O（1）快速积.看不懂的黑科技...............

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<math.h>
using namespace std;
#define ll __int64
ll a,b,c,mod;
ll kuaisucheng(ll a,ll b)
{
    a%=mod;
    b%=mod;
    return (a*b-(ll)(a/(long double )mod*b+1e-8)*mod+mod)%mod;
}
int main()
{
    while(~scanf("%I64d%I64d%I64d",&a,&b,&c))
    {
        a%=c;
        mod=c;
        ll ans=1;
        while(b)
        {
            if(b%2==1)
            {
                ans=kuaisucheng(ans,a)%mod;
                b-=1;
            }
            a=kuaisucheng(a,a)%mod;
            b/=2;
        }
        printf("%I64d\n",ans);
    }
}

11.Java A+B&&Java求斐波那契数列

import java.io.*;
import java.util.*;
import java.math.BigInteger;
import java.util.Scanner;
public class Main
{
    public static void main(String args[]) throws Exception
    {
        Scanner in = new Scanner(System.in);
        while(in.hasNext())
        {
            BigInteger a, b;
            a = in.nextBigInteger();
            b = in.nextBigInteger();
            System.out.println(a.add(b));
        }
    }
}

import java.io.*;
import java.util.*;
import java.math.BigInteger;  
 
public class Main{
    public static void main(String args[]) throws Exception {
        Scanner cin=new Scanner(System.in);
        BigInteger[] f = new BigInteger[1200];
        f[1]=BigInteger.valueOf(1);
        f[2]=BigInteger.valueOf(2);
        for(int i=3;i<=1100;i++)
        {
            f[i]=f[i-1].add(f[i-2]);
        }
        while (cin.hasNext()) {
            int cont=0;
            BigInteger l,r;
            BigInteger Zero=BigInteger.valueOf(0);
            l = cin.nextBigInteger();
            r = cin.nextBigInteger();
           if(l.compareTo(Zero)==0&&r.compareTo(Zero)==0)break;
            for(int i=1;i<=1100;i++)
            {
                if(f[i].compareTo(l)>=0&&f[i].compareTo(r)<=0)cont++;
            }
            System.out.println(cont);
        }
    }
}

12.转负二进制

Poj 3191
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int ans[1000];
int main()
{
    int a;
    while(~scanf("%d",&a))
    {
        if(a==0)
        {
            printf("0\n");
            continue;
        }
        int cont=0;
        while(a)
        {
            ans[cont++]=abs(a%(-2));
            a-=abs(a%(-2));
            a/=(-2);
        }
        for(int i=cont-1;i>=0;i--)printf("%d",ans[i]);
        printf("\n");
    }
}

13.最小表示法

#include<stdio.h>  
#include<string.h>  
#include<iostream>  
using namespace std;  
char a[3004000];  
char b[3004000];  
int l;  
int MinimumRepresentation()  
{  
    int i = 0, j = 1, k = 0, t;  
    while(i < l && j < l && k < l) {  
        t = b[(i + k) >= l ? i + k - l : i + k] - b[(j + k) >= l ? j + k - l : j + k];  
        if(!t) k++;  
        else{  
            if(t > 0) i = i + k + 1;  
            else j = j + k + 1;  
            if(i == j) ++ j;  
            k = 0;  
        }  
    }  
    return (i < j ? i : j);  
}  
int main()  
{  
    while(~scanf("%s",a))  
    {  
        int n=strlen(a);  
        l=n;  
        a[n]=a[0];  
        for(int i=0;i<n;i++)  
        {  
            if(a[i]<=a[i+1])  
            b[i]=a[i+1]-a[i];  
            else  
            b[i]=8-(a[i]-a[i+1]);  
        }  
        int tmp=MinimumRepresentation();  
        for(int z=0;z<n;z++)  
        {  
            printf("%d",b[(z+tmp)%n]);  
        }  
        printf("\n");  
    }  
}  

14.set使用实例1+lower_bound（val）

#include<stdio.h>  
#include<set>  
#include<iostream>  
#include<algorithm>  
#include<string.h>  
#include<map>  
using namespace std;  
int main()  
{  
    int n;  
    while(~scanf("%d",&n))  
    {  
        map<int ,int>lson,rson;  
        set<int >s;  
        set<int >::iterator pos;  
        for(int i=0;i<n;i++)  
        {  
            int x;  
            scanf("%d",&x);  
            if(i==0)  
            {  
                s.insert(x);  
                continue;  
            }  
            pos=s.lower_bound(x);  
            if(pos!=s.end()&&lson[*pos]==0)  
            {  
                lson[*pos]=x;  
            }  
            else  
            {  
                pos--;  
                rson[*pos]=x;  
            }  
            printf("%d ",*pos);  
            s.insert(x);  
        }  
        printf("\n");  
    }  
}  

15.后缀模？

        cc[n-1]=(a[n-1]-'0')%c;  
        int tmp=1;  
        for(int i=n-2;i>=0;i--)  
        {  
            tmp=tmp*10%c;  
            cc[i]=(cc[i+1]+tmp*(a[i]-'0'))%c;  
        } 

16.01分数规划

当有求：Σ（a【i】）/Σ（b【i】）的最大（小）值的时候，我们可以将问题转化变成减法：

设定函数F（L）=Σ（a【i】）-L*Σ（b【i】）；

若此时F（L）>=0，那么肯定有Σ（a【i】）-L*Σ（b【i】）>=0，那么就有：Σ（a【i】）/Σ（b【i】）>=L;

根据化出的等式可以得知，我们有比L更大。那么我们这里可以二分枚举这个L，同时也就是在二分枚举最终的答案。

若有F（L）>=0，我们要增大答案，相反减小答案即可。

17.离散化+Bfs实例 Fzu 2235

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
struct node
{
    int from;
    int to;
    int next;
}e[105000*8];
int cont;
int head[105000];
int dist[105000];
int fx[8]={0,0,1,-1,-1,1,-1,1};
int fy[8]={1,-1,0,0,-1,1,1,-1};
pair<int ,int >p[105000];
int cnt;
int sx,sy,ex,ey;
void add(int from,int to)
{
    e[cont].to=to;
    e[cont].next=head[from];
    head[from]=cont++;
}
void SPFA()
{
    for(int i=1;i<=cnt;i++)dist[i]=0x3f3f3f3f;
    int ss=lower_bound(p+1,p+1+cnt,make_pair(sx,sy))-p;
    int tt=lower_bound(p+1,p+1+cnt,make_pair(ex,ey))-p;
    dist[ss]=0;
    queue<int>s;
    s.push(ss);
    while(!s.empty())
    {
        int u=s.front();
        s.pop();
        for(int i=head[u];i!=-1;i=e[i].next)
        {
            int v=e[i].to;
            if(dist[v]>dist[u]+1)
            {
                dist[v]=dist[u]+1;
                s.push(v);
            }
        }
    }
    if(dist[tt]==0x3f3f3f3f)printf("-1\n");
    else printf("%d\n",dist[tt]);
}
int main()
{
    while(~scanf("%d%d%d%d",&sx,&sy,&ex,&ey))
    {
        cnt=0;
        cont=0;
        int tot;
        scanf("%d",&tot);
        memset(head,-1,sizeof(head));
        for(int i=0;i<tot;i++)
        {
            int h,l,r;
            scanf("%d%d%d",&h,&l,&r);
            for(int j=l;j<=r;j++)
            {
                p[++cnt]=make_pair(h,j);
            }
        }
        sort(p+1,p+cnt+1);
        cnt=unique(p+1,p+cnt+1)-p-1;
        for(int i=1;i<=cnt;i++)
        {
            for(int j=0;j<8;j++)
            {
                pair<int ,int >now=make_pair(p[i].first+fx[j],p[i].second+fy[j]);
                int pos=lower_bound(p+1,p+cnt+1,now)-p;
                if(p[pos].first==p[i].first+fx[j]&&p[pos].second==p[i].second+fy[j])
                {
                    add(i,pos);
                }
            }
        }
        SPFA();
    }
}

18.三分查找（int）

int Sanfen(int l,int r)
{
    int lm,rm;
    while(l<r-1)
    {
        lm=(l+r)/2;
        rm=(lm+r)/2;
        if(Slove(lm)>Slove(rm))
        {
            l=lm;
        }
        else r=rm;
    }
    return min(Slove(l),Slove(r));
}