抽签（时间复杂度）

你的朋友题意玩个游戏：将写有数字的n个纸片放入口袋里，你可以从口袋里抽取4次纸片，每次记录下纸片上的数字后再将其放回口袋。如果这四个数字的和是m，就是你赢，否则就是你的朋友赢。你挑战了好多回，结果一次也没有赢过，于是怒而撕破口袋，取出所有的纸片，检查自己是否有赢的可能。

请你编写一个程序，判断当纸片上所写的数字是 k1,k2........kn时，是否存在抽取4次和为m 的方案。如果存在，输出YES，否则输出NO

输入：

3 10

1 3 5

输出：

YES

输入：

3 9

1 3 5

输出：

NO

这里当n比较小的时候，我们可以直接用四层循环来做，可是如果n比较大的时候，这样肯定会超时

O(n^4)的做法：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<vector>
#include<cmath>
const int maxn=1e5+5;
typedef long long ll;
using namespace std;
int k[maxn];
int main(){
    int n,m;
    cin>>n>>m;
    for(int i=0;i<n;i++)
        cin>>k[i];
    bool flag=false;
    for(int a=0;a<n;a++){
    	for(int b=0;b<n;b++){
    		for(int c=0;c<n;c++){
    			for(int d=0;d<n;d++){
    				if(k[a]+k[b]+k[c]+k[d]==m){
    					flag=true;
    					break;
					}
				}
			}
		}
	}
	if(flag)
	    cout<<"YES"<<endl;
	else
	    cout<<"NO"<<endl;
    return 0;
}

上边我们检查的是：

k[a]+k[b]+k[c]+k[d]==m

通过式子移项，我们可以变成检查是否存在 d 使得

k[d] = m-k[a]-k[b]-k[c]

这里我们可以有二分查找的方法，来查找是否存在d

O(n^3logn)的做法：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<vector>
#include<cmath>
const int maxn=1e5+5;
typedef long long ll;
using namespace std;
int k[maxn];
int n,m;
bool binary_search(int x){
	int l=0;
	int r=n;
	while(l<=r){
		int mid=(l+r)/2;
		if(k[mid]==x)
		    return true;
		else if(k[mid]<x)
		    l=mid+1;
		else
		    r=mid-1;
	}
	return false;
}
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++)
        cin>>k[i];
    sort(k,k+n);
    bool flag=false;
    for(int a=0;a<n;a++){
    	for(int b=0;b<n;b++){
    		for(int c=0;c<n;c++){
    			if(binary_search(m-k[a]-k[b]-k[c])){
    			    flag=true;
				}
			}
		}
	}
	if(flag)
	    cout<<"YES"<<endl;
	else
	    cout<<"NO"<<endl;
    return 0;
}

其实不用二分查找，直接用一个标记数组，标记一下k数组中出现过的数，可以做到O(n^3)

O（n^3）的做法：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<vector>
#include<cmath>
const int maxn=1e5+5;
typedef long long ll;
using namespace std;
int k[maxn];
int n,m;
int vis[maxn];
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++){
        cin>>k[i];
		vis[k[i]]=1;
	}
    bool flag=false;
    for(int a=0;a<n;a++){
    	for(int b=0;b<n;b++){
    		for(int c=0;c<n;c++){
    			if(vis[m-k[a]-k[b]-k[c]]==1){
    			    flag=true;
				}
			}
		}
	}
	if(flag)
	    cout<<"YES"<<endl;
	else
	    cout<<"NO"<<endl;
    return 0;
}

但是当n=1000是 n^3的算法还是不能满足要求

这里把上边的算法优化一下，还是刚才的思路

检查是否有c 和 d满足 k[c] + k[d] = m - k[a] - k[b]

这种情况并不能直接使用二分查找，但是可以预先枚举k[c]+k[d]所得到的 n^2 个数字并排好序，便可以利用二分查找

O(n^2logn)的做法：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<vector>
#include<cmath>
const int maxn=1e5+5;
typedef long long ll;
using namespace std;
int k[maxn];
int kk[maxn];
int n,m;
bool binary_search(int x){
	int l=0;
	int r=n*n;
	while(l<=r){
		int mid=(l+r)/2;
		if(kk[mid]==x)
		    return true;
		else if(kk[mid]<x)
		    l=mid+1;
		else
		    r=mid-1;
	}
	return false;
}
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++)
        cin>>k[i];
    for(int i=0;i<n;i++){
    	for(int j=0;j<n;j++){
    		kk[i*n+j]=k[i]+k[j];
		}
	}
	sort(kk,kk+n*n);
    bool flag=false;
    for(int a=0;a<n;a++){
    	for(int b=0;b<n;b++){
    		if(binary_search(m-k[a]-k[b])){
    			flag=true;
			}
		}
	}
	if(flag)
	    cout<<"YES"<<endl;
	else
	    cout<<"NO"<<endl;
    return 0;
}

同样还是可以用一个标记数组来操作

O(n^2)的做法：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<vector>
#include<cmath>
const int maxn=1e5+5;
typedef long long ll;
using namespace std;
int k[maxn];
int n,m;
int vis[maxn];
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++)
        cin>>k[i];
    for(int i=0;i<n;i++){
    	for(int j=0;j<n;j++){
    		vis[k[i]+k[j]]=1;
		}
	}
    bool flag=false;
    for(int a=0;a<n;a++){
    	for(int b=0;b<n;b++){
    		if(vis[m-k[a]-k[b]]==1){
    			flag=true;
			}
		}
	}
	if(flag)
	    cout<<"YES"<<endl;
	else
	    cout<<"NO"<<endl;
    return 0;
}