和谐的奶牛Balanced Cow Breeds

最新推荐文章于 2020-03-14 22:36:29 发布

原创最新推荐文章于 2020-03-14 22:36:29 发布 · 520 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#C++

信息学专栏收录该内容

77 篇文章

订阅专栏

本文介绍了一种算法，用于将由左括号和右括号组成的奶牛序列分割成两个平衡子序列。通过动态规划从字符串末尾开始计算，考虑两个虚拟奶牛品种A和B，确保分割后的序列保持平衡。算法复杂度为O(n^2)，适用于序列长度在111到1000之间的场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

农夫约翰的奶牛们排成了一条直线，每只奶牛都有一个标识符，这个标识符是左括号或者右括号。约翰希望将这个奶牛序列分成两个子序列，并且不改变序列中原来的字符顺序。同时，要求这两个子序列都是平衡序列。
平衡序列是这么定义的：序列中左括号和右括号的个数是一样的，同时这个序列的所有前缀串中左括号的个数不少于右括号的个数。

例如图1都是平衡序列。
()
(())
()(()())
图2都不是平衡序列。
)(
())(
((())))
请你帮助约翰计算将原来的奶牛序列分成两个平衡子序列的方案数。

输入

只有一个奶牛的序列，都是由左括号和右括号组成的。

输出

总的方案数。

样例输入

(())

样例输出

数据范围限制

序列的长度是 $1$ 到 $1000$ 。

题解

We’ll call the two breeds A and B for convenience. Let the input string $S = s_1s_2...s_n$ . We will give a dynamic programming algorithm working backwards from the end of the string.

Let $f(i,A_{open}, B_{open})$ be the number of ways to assign $s_i...s_n$ to breeds such that the resulting two parentheses-strings are balanced, given that we have $A_{open}$ unmatched left-parenthesis of type A and B_open unmatched left-parentheses of type B. If $S [i] = =^{'} (^{'}$ , then $f(i,A_{open}, B_{open}) = f(i+1, A_{open}+1, B_{open}) + f(i+1, A_{open}, B_{open} + 1)$ , since we can assign the parenthesis to breed A or breed B. If $S [i] = =^{'})^{'}$ , then we can assign the parenthesis to breed A as long as $A_{open} > 0$ , and to B as long as $B_{open} > 0$ .

The base case is i=n, in which case we processed the whole string without violating any invariants. As the total number of ')'s equals to the total number of $^{'} (^{'}$ s, we wil end up with two balanced strings of parentheses. Therefore we can start with so $f (n, 0, 0) = 1$ .

We have $0 <= i <= n, 0 <= A_{open} <= n, 0 <= B_{open} <= n$ , so the number of states is $O(n^3)$ , and there is $O (1)$ non-recursive overhead for each state, so this leads to an $O(n^3)$ solution.

Unfortunately, $O(n^3)$ isn’t fast enough with $n = 1, 000$ . We can do better by noticing that $B_{open}$ is uniquely determined by i and $A_{open} (because A_{open} + B_{open}$ sums to the number of unmatched left-parentheses in $s_1...s_{i-1})$ . So it suffices to keep track of $i, A_{open})$ , which gives $O(n^2) states \ and\ an O(n^2)$ solution. This is fast enough.

Code

#include <iostream>
#include <vector>
#include <cstring>
#include <cstdio>
using namespace std;
#define MOD 2012
#define MAXN 1010
int a[MAXN];
int main() 
{
    freopen("bbreeds.in","r",stdin);
    freopen("bbreeds.out","w",stdout);
    int l = a[1] = 1;
    for(int ch = cin.get();l > 0 && ch == '(' || ch == ')';ch = cin.get()) 
    {
        int dir = ch == '(' ? 1 : -1;
        l += dir;
        for(int j = dir < 0 ? 1 : l;1 <= j && j <= l; j -= dir) 
        {
            a[j] += a[j - dir];
            if(a[j] >= MOD) 
                a[j] -= MOD;
        }
    a[l + 1] = 0;
  }
  cout << (l == 1 ? a[1] : 0) << endl;
}