NOIP2011选择客栈

求lcp ： Trie + lca

题目：选择客栈

https://www.luogu.org/problem/show?pid=1311

感谢Loi_cgold,文章转载自http://my.csdn.net/qq_36312502

挺有意思的一道题；

先考虑n^2*k的做法;
开链表直接模拟；
用st表维护区间最小值；

pre[i]：与i颜色相同的前一个客栈的位置；
h[x]：最后一个颜色为x的客栈的位置；

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
const int MAXN=200001;
int dp[MAXN][21],pre[MAXN],h[MAXN];
int n,k,c,tot;
struct ST
{
    void st_init()
    {
        for(int j=1;(1<<j)<=n;j++)
            for(int i=1;i+(1<<j)-1<=n;i++)
                dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
        return;
    }
    int query(int l,int r)
    {
        int k=log2(r-l+1);
        return min(dp[l][k],dp[r-(1<<k)+1][k]);
    }
}st;
void solve()
{
    int x;
    memset(h,0,sizeof(h));
    memset(pre,0,sizeof(pre));
    scanf("%d%d%d",&n,&k,&c);
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&x,&dp[i][0]);
        pre[i]=h[x];
        h[x]=i;
    }
    st.st_init();
    for(int x=0;x<k;x++)
        for(int i=h[x];i;i=pre[i])
            for(int j=pre[i];j;j=pre[j])
            {
                int xx=j,yy=i;  
                if(st.query(xx,yy)<=c) tot++;
            }
    cout<<tot;
}
int main()
{
    solve();
    return 0;
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
   
   

    
    
   
   

我们发现，在找相同颜色客栈的方案数时，有许多的方案数被重复计算；

所以，考虑优化;

tot[k]：记录之前颜色为k的客栈出现的次数；
sum[k] : 记录之前“已找到小于花费”的颜色为k的客栈出现次数；
h[k] : 上一个颜色为k的客栈出现的位置；

所以两个颜色相同的客栈之间有小于花费的咖啡店；
将sum更新为tot即可；

ST表：O(nlogn)
模拟：O(n);
总复杂度O(nlogn)；

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
const int MAXN=200001;
int dp[MAXN][21],pre[MAXN],h[MAXN],cnt[MAXN];
int n,k,c,tot[MAXN],sum[MAXN],s[MAXN],ans;
struct ST
{
    void st_init()
    {
        for(int j=1;(1<<j)<=n;j++)
            for(int i=1;i+(1<<j)-1<=n;i++)
                dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
        return;
    }
    int query(int l,int r)
    {
        int k=log2(r-l+1);
        return min(dp[l][k],dp[r-(1<<k)+1][k]);
    }
}st;
void solve()
{
    int x;
    memset(h,0,sizeof(h));
    memset(pre,0,sizeof(pre));
    scanf("%d%d%d",&n,&k,&c);
    for(int i=1;i<=n;i++)
        scanf("%d%d",&s[i],&dp[i][0]);
    st.st_init();
    for(int i=1;i<=n;i++)
    {
        if(!h[s[i]])
        tot[s[i]]++,h[s[i]]=i;
        else
        {
            if(st.query(h[s[i]],i)<=c)
            ans+=tot[s[i]],sum[s[i]]=tot[s[i]];
            else ans+=sum[s[i]];
            tot[s[i]]++,h[s[i]]=i;
        }
    }
    cout<<ans;
}
int main()
{
    solve();
    return 0;
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
   
   

    
    
   
   

其实ST表也可以优化掉；
我们只需要找到离当前“最近”（也可以是当前位置）的小于花费的客栈；
如果这个客栈在上一个与当前颜色相同的客栈后面，那么直接更新sum，sum=tot；
此时的时间复杂度为O(n);

#include<cstdio>
int n,k,c,now,x,y,ans;
int sum[1001],tot[1001],h[1001];
int main()
{
    scanf("%d%d%d",&n,&k,&c);
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&x,&y);
        now=(y<=c?i:now);
        if(now>=h[x]) sum[x]=tot[x];
        h[x]=i,ans+=sum[x],tot[x]++;
    }
    printf("%d",ans);
    return 0;
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
   
   

    
    
   
   

总结：
1.这种题还是要多练；
2.考虑用数据结构进行优化;