poj 3167 Cow Patterns ... 四种算法 (均结合kmp)

最新推荐文章于 2018-07-29 12:14:45 发布
最新推荐文章于 2018-07-29 12:14:45 发布
阅读量864 收藏
点赞数
分类专栏： kmp 文章标签： 算法 struct c c++ user
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/imissher/article/details/8096604
版权

题目链接：http://poj.org/problem?id=3167


第1,2种算法思路是一样的，但是实现方法不同。

算法归于以下结论：两个序列的偏序相同则两序列同一位以前小于它和等于它的数的数量应该是相同的。

比如：题目匹配的结果是： 2 10 10 7 3 2

                                            1   4   4 3  2 1 --- >>> 说不清楚^_^...

现在的目的就是找出如何快速的算出一个序列每一位前面有多少元素小于它，多少元素等于它？

第一种方法：树状数组。同时理解kmp匹配时候总是按非递减的数量舍弃前面不能匹配的值。 这样可以用一个TreeArray来保存舍弃的值。然后减去即可。主要还是看代码吧。

第二种方法：因为s很小，所以可以直接开一个数组保存每一位前面每种元素出现的次数。暴力 + kmp。


1：树状数组实现


//Problem: 3167		User: _missing
//Memory: 2040K		Time: 313MS
//Language: C++		Result: Accepted

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;
const int MAXN = 100000 + 1000;

struct TreeArray
{
    int N, *C;
    TreeArray(int N =0, int *C =0): N(N), C(C) { Init(); }
    void Init() { memset(C, 0, sizeof(int)*(N+1)); }
    int  lowbit(int x) { return x&(-x); }
    void Add(int x, int v)
    {
        while (x <= N)
        {
            C[x] += v;
            x += lowbit(x);
        }
    }
    int  Sum(int x)
    {
        int res =0;
        while (x > 0)
        {
            res += C[x];
            x -= lowbit(x);
        }
        return res;
    }
    int  Equ(int x) { return Sum(x)-Sum(x-1); }
    int  Low(int x) { return Sum(x-1); }
};
struct Cow
{
    int num[MAXN];
    int low[MAXN];
    int equ[MAXN];
};

Cow  cow, pot;
int  nxt[MAXN];
int  ans[MAXN];
int  arr[30];
int  n, k, s;

void Init(Cow &cow, int n)
{
    TreeArray ta(s, arr);
    for ( int i =1; i <= n; i++)
    {
        ta.Add(cow.num[i], 1);
        cow.low[i] = ta.Low(cow.num[i]);
        cow.equ[i] = ta.Equ(cow.num[i]);
    }

    //for ( int i =1; i <= n; i++) printf("%d ", cow.low[i]); cout << endl;
    //for ( int i =1; i <= n; i++) printf("%d ", cow.equ[i]); cout << endl; 
    //cout << endl;
}

void GetNext()
{
    TreeArray sub(s, arr);
    sub.Add(pot.num[1], 1);
    nxt[1] = 0;
    
    for ( int i =2, j =0; i <= k; i++)
    {
        while (j>0 && (pot.low[j+1] != pot.low[i]-sub.Low(pot.num[i]) 
                   ||  pot.equ[j+1] != pot.equ[i]-sub.Equ(pot.num[i])))
        {
            for ( int k =i-j; k < i-nxt[j]; k++) sub.Add(pot.num[k], 1);
            j = nxt[j];
        }

        if ( pot.low[j+1] == pot.low[i]-sub.Low(pot.num[i]) &&
             pot.equ[j+1] == pot.equ[i]-sub.Equ(pot.num[i]) )
             ++j;
        else
            sub.Add(pot.num[i], 1);
        
        nxt[i] = j;
    }

    //for ( int i =1; i <= k; i++) printf("%d ", nxt[i]); cout << endl;
}

void Sunshine()
{
    int &c = ans[0]; 
    c = 0;
    TreeArray sub(s, arr);

    for ( int i =1, j =0; i <= n; i++)
    {
        while (j>0 && (pot.low[j+1] != cow.low[i]-sub.Low(cow.num[i]) 
                   ||  pot.equ[j+1] != cow.equ[i]-sub.Equ(cow.num[i])))
        {
            for ( int k =i-j; k < i-nxt[j]; k++) sub.Add(cow.num[k], 1);
            j = nxt[j];
        }

        if ( pot.low[j+1] == cow.low[i]-sub.Low(cow.num[i]) &&
             pot.equ[j+1] == cow.equ[i]-sub.Equ(cow.num[i]) )
             ++j;
        else
            sub.Add(cow.num[i], 1);

        if (j == k) ans[++c] = i-k+1;
    }
}

int main()
{
    //freopen("h:\\data.in", "r", stdin);
    //freopen("h:\\data.out", "w", stdout);

    scanf("%d%d%d", &n, &k, &s);
    for ( int i =1; i <= n; i++) scanf("%d", cow.num+i);
    for ( int i =1; i <= k; i++) scanf("%d", pot.num+i);

    Init(cow, n);
    Init(pot, k);

    GetNext();
    Sunshine();

    for ( int i =0; ans[0] && i<=ans[0]; i++) printf("%d\n", ans[i]);
    return 0;
}

2：暴力数组实现

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int MAXN = 100000 + 1000;
struct Cow
{
    int num[MAXN];
    int low[MAXN][26];  // low[i][j]: i位置前比j小的元素数量
    int equ[MAXN][26];  // equ[i][j]: i位置前(包括i)与j相等的元素数量
};
Cow cow, pot;
int n, k, s;
int nxt[MAXN];
int ans[MAXN];

void Init(Cow &cow, int n)
{
    for ( int i =1; i <= n; i++)
        for ( int j =1; j <= s; j++)
            cow.low[i][j] = cow.low[i-1][j] + (cow.num[i]<j ? 1 : 0),
            cow.equ[i][j] = cow.equ[i-1][j] + (cow.num[i]==j ? 1 : 0);
}

void GetNext()
{
    nxt[1] = 0;
    for ( int i =2, j =0; i <= k; i++)
    {
        while (j>0 && (pot.low[j+1][pot.num[j+1]] != pot.low[i][pot.num[i]] - pot.low[i-j-1][pot.num[i]] 
                   ||  pot.equ[j+1][pot.num[j+1]] != pot.equ[i][pot.num[i]] - pot.equ[i-j-1][pot.num[i]]))
            j = nxt[j];

        if (pot.low[j+1][pot.num[j+1]] == pot.low[i][pot.num[i]] - pot.low[i-j-1][pot.num[i]] &&
            pot.equ[j+1][pot.num[j+1]] == pot.equ[i][pot.num[i]] - pot.equ[i-j-1][pot.num[i]])
            ++j;
        
        nxt[i] = j;
    }

    //for ( int i =1; i <= k; i++) cout << nxt[i] << " "; cout << endl;
}

void Sunshine()
{
    int &c = ans[0];
    c = 0;

    for ( int i =1, j =0; i <= n; i++)
    {
        while (j>0 && (pot.low[j+1][pot.num[j+1]] != cow.low[i][cow.num[i]] - cow.low[i-j-1][cow.num[i]]
                   ||  pot.equ[j+1][pot.num[j+1]] != cow.equ[i][cow.num[i]] - cow.equ[i-j-1][cow.num[i]]))
            j = nxt[j];

        if (pot.low[j+1][pot.num[j+1]] == cow.low[i][cow.num[i]] - cow.low[i-j-1][cow.num[i]] &&
            pot.equ[j+1][pot.num[j+1]] == cow.equ[i][cow.num[i]] - cow.equ[i-j-1][cow.num[i]])
            ++j;
        
        if (j == k) ans[++c] = i-k+1;
    }
}

int main()
{
    //freopen("h:\\data.in", "r", stdin);
    //freopen("h:\\data.out", "w", stdout);

    scanf("%d%d%d", &n, &k, &s);
    for ( int i =1; i <= n; i++) scanf("%d", &cow.num[i]);
    for ( int i =1; i <= k; i++) scanf("%d", &pot.num[i]);

    Init(cow, n);
    Init(pot, k);

    GetNext();
    Sunshine();

    for ( int i =0; ans[0] && i<=ans[0]; i++) printf("%d\n", ans[i]);
    return 0;
}


第三种算法参照：http://www.cppblog.com/zxb/archive/2010/10/06/128782.aspx?opt=admin

//Time: 266MS

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int MAXN = 100000 + 1000;
int cow[MAXN], pot[MAXN];
int occur[30], low[MAXN], high[MAXN];
int nxt[MAXN];
int ans[MAXN];
int n, k, s;

bool Comp(int *a, int *b, int k)
{
    if (b[occur[a[k]]] != b[k]) return false;
    if (low[k]>0 && b[low[k]]>=b[k]) return false;
    if (high[k]>0 && b[high[k]]<=b[k]) return false;
    return true;
}

void GetNext()
{
    nxt[1] = 0;
    for ( int i =2, j =0; i <= k; i++)
    {
        while (j>0 && !Comp(pot, pot+i-j-1, j+1)) j =nxt[j];
        
        if (Comp(pot, pot+i-j-1, j+1)) ++j;
        nxt[i] = j;
    }
    //for ( int i =1; i <= k; i++) cout << nxt[i] << " "; cout << endl;
}

void Sunshine()
{
    int &c = ans[0]; c =0;
    for ( int i =1, j =0; i <= n; i++)
    {
        while ((j>0 && !Comp(pot, cow+i-j-1, j+1))) j =nxt[j];

        if (Comp(pot, cow+i-j-1, j+1)) ++j;
        if (j == k)
        {
            ans[++c] = i-j+1;
            j = nxt[j];
        }
    }
}

int main()
{
    //freopen("h:\\data.in", "r", stdin);
    //freopen("h:\\data.out", "w", stdout);

    scanf("%d%d%d", &n, &k, &s);
    for ( int i =1; i <= n; i++) scanf("%d", cow+i);
    for ( int i =1; i <= k; i++) scanf("%d", pot+i);

    for ( int i =1, j; i <= k; i++)
    {
        // occur, low, high, 值为0表示未出现。
        if (occur[pot[i]] == 0) occur[pot[i]] = i;
        for ( j =pot[i]-1; j>0 && occur[j] == 0; --j);
        low[i] = occur[j];
        for ( j =pot[i]+1; j<=s && occur[j] == 0; ++j);
        high[i] = occur[j];
    }

    GetNext();
    Sunshine();
    
    for ( int i =0; ans[0] && i<=ans[0]; ++i) printf("%d\n", ans[i]);
    return 0;
}


第四种算法是依次枚举模版串中第i大的数，然后分别进行kmp匹配。枚举时的第二大的数必须比第一大的大……

//Time: 954MS
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int MAXN = 100000 + 1000;

bool occur[30];
int  cow[MAXN], pot[MAXN];
bool tcow[MAXN], tpot[MAXN];
int  match[MAXN], cnt[MAXN]; // 记录匹配次数
int  ans[MAXN];
int  nxt[MAXN];
int  n, k, s;

void GetNext()
{
    nxt[1] = 0;
    for ( int i =2, j =0; i <= k; i++)
    {
        while (j>0 && tpot[j+1] != tpot[i]) j =nxt[j];
        if (tpot[j+1] == tpot[i]) ++j;
        nxt[i] = j;
    }
}
void Sunshine(int c)
{
    for ( int i =1; i <= n; i++) tcow[i] = (cow[i]==c ? true : false);
    for ( int i =1, j =0; i <= n; i++)
    {
        while (j>0 && tpot[j+1]!=tcow[i]) j =nxt[j];
        if (tpot[j+1] == tcow[i]) ++j;
        if (j == k)
        {
            int p = i-j+1;
            if (cnt[p]==cnt[0] && match[p]<c)
            {
                cnt[p]++;
                match[p]=c;
            }
            j = nxt[j];
        }
    }
}

int main()
{
    //freopen("h:\\data.in", "r", stdin);
    //freopen("h:\\data.out", "w", stdout);

    scanf("%d%d%d", &n, &k, &s);
    for ( int i =1; i <= n; i++) scanf("%d", cow+i); 
    for ( int i =1; i <= k; i++) 
    {
        scanf("%d", pot+i);
        occur[pot[i]] = true;
    }

    for ( int i =1; i <= s; i++)
    {
        // 枚举第i大的数是j
        if (!occur[i]) continue;
        for ( int j =1; j<= k; j++) tpot[j] = (pot[j]==i ? true : false);
        GetNext();
        for ( int j =1; j <= s; j++) Sunshine(j); // 表示模版串中的i对应于原串中的j的时候的匹配结果
        
        cnt[0]++;  // 统计匹配次数
    }

    for ( int i =1; i <= n; i++)
        if (cnt[i] == cnt[0]) ans[++ans[0]] = i;

    if (ans[0])
        for ( int i =0; i <= ans[0]; ++i) printf("%d\n", ans[i]);
    
    return 0;
}

ok.....这是一个kmp好题啊。

MoonBall_cxy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ 3167 Cow Patterns（KMP算法变形）
da_kao_la的博客
09-13 507
题目来源：http://poj.org/problem?id=3167 问题描述 Cow Patterns Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 5200   ...
pku 3167 Cow Patterns（kmp）
街角的花街糖
07-29 826
Cow Patterns Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 2610   Accepted: 972 Description A particular subgroup of K (1 <= K <= 25,000) of Farmer John'
poj 3167
mars_ch的博客
11-01 284
好题啊kmp+树状数组可以加深 kmp的理解在求next数组的时候 匹配条件不应该是 b[i]=b[j]吗 我们把他改成 我们体力所需要的条件 也就是rank[i]=rank[j] rank是什么呢就是当前数前面比他小的和和他相等的，只要跟模式串一样就ok 所以 就ok了#include<cstdio> #include<algorithm> #include<cstring> #def
POJ3167
Pleaseinput的博客
07-29 651
KMP上跑浮动的模式串 一个农场主有N头牛，每个牛都以它身上的斑点数作为标志，以斑点数作为标准对牛进行rank排序，定义牛的序列的相同性为第i头牛及其之前的牛的比他rank小的数量和与他rank相同的数量，比如： 1 4 4 3 2 1 和 2 10 10 7 3 2 是一样的模式串 要求数有多少个符合要求的模式串，并输出每个符合要求的子串的起始位置。   KMP！！！太强啦，将这个浮动...
POJ 3167
Since_natural_ran
12-05 396
POJ 3167题意：​ 原串长度为n，匹配串长度为m，输出匹配串在原串中出现几次，并且输出其出现的位置。思路：​ 利用kmp的思想，求出Next数组，求的方法是对于数字的排列存在规律，因为两个数列不同只能比较相对大小，其体现在当前数字之前的比其小的个数和与之相等的个数，预处理其存在的个数。​ as[i][j]as[i][j] : 在a[i]a[i] 位置之前（包括本身）k数字存在的个数
poj 3266 Cow School.md
11-17
poj 3266 Cow School.md
POJ3322.rar_poj33_www.3322.se.c
09-19
这里的"算法：宽搜"指的是宽度优先搜索（Breadth-First Search），这是一种用于遍历或搜索树或图的算法，特别适用于寻找最短路径。由于问题涉及到矩形方块，因此在实际应用中，可能需要考虑矩形的边角碰撞检测以及...
KMP.rar_kmp poj
最新发布
09-19
本文将深入探讨KMP算法的基本原理、实现过程，并结合POJ上的实际题目，展示其在解决实际问题中的应用。 KMP算法的核心思想是避免对已比较过的字符进行重复比较，通过构建失配表来提高搜索效率。失配表记录了字符串...
poj:在poj.org上做的一些算法题
06-25
【标题】"poj.org算法题解集合"是关于在poj.org平台上解决的各种算法问题的集合，这个资源主要是为了帮助编程爱好者和学习者提升算法技能。poj.org是一个著名的在线编程竞赛平台，它提供了丰富的算法题目供用户实践...
poj算法题目实现.zip_algorithm_arrangement4hv_conditionyis_poj problems
09-15
在本压缩包“poj算法题目实现.zip”中，包含了五个经典的编程竞赛题目，主要针对的是POJ（Programming Online Judge）平台。这些题目是程序员提升算法能力、锻炼编程技巧的重要资源。下面，我们将详细探讨每个题目...
poj3167
weixin_34176694的博客
09-11 83
这道题是一道kmp的扩展版的好题一串匹配一串很容易想到kmp，但是这里的匹配要求的是两个串的名次相同显然名次是会变的，为了方便，我们可以换一种表达对于两个等长的串的相同位置，名次相等就是在它之前比它小的数的个数一样，和它相等的数的个数一样这个我们可以用树状数组维护一下（当然暴力好像也行）然后匹配就行了 1 var ans,a,b,sal,eq:array[0..100010] of l...
kmp poj 3167
涛涛不解
04-19 1771
参考了这个http://www.cppblog.com/zxb/archive/2010/10/06/128782.aspx?opt=admin 他用的是hash的思想 题目大意是：给一个字符串，在给个子串，求子串是否在是整个字符串的子串，字符串之间的匹配遵循相对位置 例如给定：5 6 2 10 10 7 3 2 9 然后子串：       1 4 4 3 2 1它与 2 10 10 7
POJ 3167 Cow Patterns
Faxth
09-26 695
题目链接：http://poj.org/problem?id=3167Description约翰的N(1≤N≤100000)只奶牛中出现了K(1≤K≤25000)只爱惹麻烦的坏蛋。奶牛们按一定的顺序排队的时候，这些坏蛋总会站在一起。为了找出这些坏蛋，约翰让他的奶牛排好队进入牛棚，同时需要你的慧眼来识别坏蛋，为了区分，约翰给所有奶牛都发了号牌，上面写着一个1~S(1≤S≤25)之间的数字。虽然这不是一
POJ 3167 Cow Patterns （KMP+前缀和）
weixin_34384557的博客
09-14 99
题意：给你两串数字，长度分别为n和m，数字大小在[1,25]。当后一串数字每个数字的排名位置与前一串数字（任一长度为m的子串）每个数字的排名位置一致时就完全匹配，最后求哪些位置是完全匹配的。 例如：1 4 2 5 3 6 与 1 3 2 4 答案就是：1 3（第一串数字的第一个位置开始与第三个位置开始） 挺难想的一个题，我们需要使用dp的思想加前缀和进行KMP匹配 首先，两串数字串完...
poj3167 Cow Patterns
YHaX的博客
08-28 1387
问题转化+kmp
poj 3167 （kmp 好题）
沉溺的专栏
10-12 905
题目：http://poj.org/problem?id=3167 题目大意：给你两个数列a、b,长度分别为 n 、k，让你用 b 去匹配 a，只要是两者的相对大小对的上就算匹配，让你求出所有的 匹配的位置。 思路：KMP好题！kmp 是顺序匹配的，建设前面已经匹配了，现在正在匹配 i 和 j ，因为是相对大小，如果i位置的前面比a[ i ]的 数目和 j 位置比b[ j ] 小的数目相等
Poj 3167 Cow Patterns Hdu 4749 Parade Show (KMP大小关系相同匹配+树状数组)
whyorwhnt的专栏
06-15 985
两道题差不多，区别在于匹配时是否允许重叠
POJ题目分析与理解
05-15
想看看自己的编程能力到底怎么样，很多人都回去做一做POJ的题目吧，在这里你不妨可以先看看它的题目分析。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值