HDU 5247 找连续数 【法1：双指针+滑动窗口单调队列】【法2：DP】

找连续数

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2437    Accepted Submission(s): 884

 

Problem Description

小度熊拿到了一个无序的数组，对于这个数组，小度熊想知道是否能找到一个k 的区间，里面的 k 个数字排完序后是连续的。

现在小度熊增加题目难度，他不想知道是否有这样的 k 的区间，而是想知道有几个这样的 k 的区间。

 

Input

输入包含一组测试数据。

第一行包含两个整数n，m，n代表数组中有多少个数字，m 代表针对于此数组的询问次数，n不会超过10的4次方，m 不会超过1000。第二行包含n个正整数，第 I 个数字代表无序数组的第 I 位上的数字，数字大小不会超过2的31次方。接下来 m 行，每行一个正整数 k，含义详见题目描述，k 的大小不会超过1000。

 

Output

第一行输"Case #i:"。(由于只有一组样例，只输出”Case #1:”即可)

然后对于每个询问的 k，输出一行包含一个整数，代表数组中满足条件的 k 的大小的区间的数量。

 

Sample Input

6 2 3 2 1 4 3 5 3 4

 

Sample Output

Case #1: 2 2

 

Source

2015年百度之星程序设计大赛 - 初赛(1)

法1：

用滑动窗口（单调队列）找出每个窗口(大小为k)内的最大值和最小值，

如果连续，在窗口内没有重复元素的情况下，最大值-最小值应该等于k 

/*
8 1
7 7 7 8 6 5 7 7
3
*/
#include <bits/stdc++.h>
using namespace std;
const int N=1e5+10;
typedef long long LL;
int a[N];
int q[N];  
int ans[N],minv[N],maxv[N];
int st[N];
int mp[N];

int main()
{
    
    int n,m;
    scanf("%d%d",&n,&m);

    for(int i=0;i<n;i++)
    scanf("%d",&a[i]);
    
   
    
    for(int co=1;co<=m;co++)
    {
        
        memset(minv,0,sizeof minv);
        memset(q,0,sizeof q);
        memset(st,0,sizeof st);
        memset(mp,0,sizeof mp);
        int k;
        scanf("%d",&k);

     //判定一下哪里有重复的元素
    for(int i=0;i<=k-1;i++)
    {
        mp[a[i]]++;
        //cout<<mp[a[i]]<<endl;
        if(mp[a[i]]==2) st[k-1]++;
    }
    
    int j=0;
    for(int i=k;i<n;i++)
    {
        st[i]=st[i-1];
        mp[a[i]]++;
        if(mp[a[i]]==2) st[i]++;
        
        while(i-j+1>k&&j<=i)
        {
            //cout<<"chuqvde j"<<a[j]<<endl; 
            mp[a[j]]--;
            if(mp[a[j]]==1) st[i]--; 
            j++;
        }
    }


    //找每个窗口的最小值
    int hh=0,tt=-1; 
    LL sum=0; 
    for(int i=0;i<n;i++)
    {
        if(hh<=tt&&i-k+1>q[hh])  hh++; 

        while(hh<=tt&&a[q[tt]]>=a[i]) tt--; 
        q[++tt]=i;  
        if(i>=k-1) 
        {
        minv[i]=a[q[hh]];
        }
    }
   
    //找每个窗口的最大值
    hh=0,tt=-1;  
    for(int i=0;i<n;i++)
    {
     
        if(hh<=tt&&i-k+1>q[hh])  hh++; 
       

        while(hh<=tt&&a[q[tt]]<=a[i]) tt--;  

        q[++tt]=i;  

        if(i>=k-1) 
        {
        maxv[i]=a[q[hh]];
        if(a[q[hh]]-minv[i]+1==k&&st[i]==0) sum++;    //st[i]负责标记该窗口是否没有重复元素
        }
    }
  
    ans[co]=sum;
   }
   
   printf("Case #1:\n");
   for(int i=1;i<=m;i++)
   printf("%d\n",ans[i]);
   return 0;
}

 方法2：（求出所有，然后输出要找的）

类似于DP的状态表示思路（只是利用这个思路形成一个数组,具体看代码上部的讲解）

这个方法较上个方法的优化：

上个方法中，我说了，要满足是k区间，这个区间（长度为k）

不仅需要  最大值-最小值+1=k

也需要  没有重复出现的元素

------------------------------------------------------------

ps:如果有重复出现的元素，会有什么影响呢？

假设k=3

区间 1 1 3

确实是 maxv-minv+1==3, 但是不连续了

------------------------------------------------------------

而此的优化之处：

用 set 的大小  来判断是否存在重复元素

如果没有重复元素，set的大小应当和区间长度一样大

如果有重复元素，set的大小会比区间的长度小

 

/*
DP的问题好像大部分是这样的规律：
DP数组一般是这样的~
最终我要求出某个给定数值条件的答案，
这个条件会放在DP数组的下标上。

比如说，我要求k的区间的数量，
dp[k]就是这个结果。 (尤其是多个询问不同的k,干脆把所有状态都求出来)

如果这样想，就比较方便第一步去想出状态表示。（也就是DP数组） 
*/ 

/*
现在来说状态表示就是 dp[i]
表示长度为i的，且i个数字排序后可以连续的  区间的数量 
*/ 

/*
本题其实不算真正的DP，只是一个类似于模拟的过程
但是这个核心的  数组名[区间长度] 在DP题中出现过 
*/ 

#include <bits/stdc++.h>
using namespace std;
const int N=1e3+10,M=1e4+10;
int n,m;
int ans[N];  //上述描述的数组 
int a[M]; 


void solve()
{
	set<int> s; //利用长度来判断是否有重复元素 
	for(int i=0;i<n;i++)
	{
		int j=i;
		s.clear();
		int minv=9999,maxv=-1; 
		while(j<=i+1000-1&&j<n) //k最大是1000 
		{
			s.insert(a[j]);
			minv=min(minv,a[j]);
			maxv=max(maxv,a[j]);
			
			//如果某个不定长度的区间满足最大最小值只差=区间长度
			//并且满足没有重复元素 
			if(maxv-minv+1==j-i+1&&s.size()==j-i+1)
			{
				ans[j-i+1]++;
			}
			j++;
		}
	}
}

int main()
{
	printf("Case #1:\n");
	cin>>n>>m;
	
	for(int i=0;i<n;i++)
	{
		cin>>a[i];
	}
	
	solve();
	
	for(int i=1;i<=m;i++)
	{
		int k;
		cin>>k;
		cout<<ans[k]<<endl;
	}
	
	return 0;
}