zoukankan      html  css  js  c++  java
  • 2017 NAIPC A:Pieces of Parentheses

    my team solve the problem in the contest with similar idea
    this is a more deep analysis
    The main idea is that if some comparator can be defined so that,
    if the pieces are previously sorted, always exist some optimal solution
    that can be formed following this order,
    then doing basic dp we arrive at the solution
    The same notation:
    pre = minimum prefix sum
    len = length of bracken
    sum = sum ( = +1 and ) = -1
    Note that we can ignore the couples of open-closed parentheses(without change the len property) for one more clear view, this do not change any thing, then exist three types of pieces
     
    1 - Open Type
        (())(( --------> is ((
        ((()( ---------> is (((
        pre >= 0
    2 - Closed-Open Type
        ()))()( -------> is ))(
        ))))(())())(()(---> is )))))((
        pre < 0 && pre != sum
    3 - Closed Type
        )))())---------> is )))))
        ()()()())))----> is )))
        pre < 0 && pre == sum
    The Closed-Open Type has two subtypes:
    2.1 - Incremental Closed-Open ( more open parentheses that closed parentheses )
          ))()())(((( -----> is )))((((
          )()(((((((( -----> is )((((((((
          pre < 0 && pre != sum && sum >= 0
    2.2 - Decremental Closed-Open ( more closed parentheses that open parentheses )
          ))()())(( -----> is )))((
          ))()( -----> is ))(
          pre < 0 && pre != sum && sum < 0
    Any correct sequence of pieces can be reorder in this way:
    first --------> open pieces ( in any order )
    next  --------> incremental-closed-open pieces ( in decreasing order of pre )
    next  --------> decremental-closed-open pieces ( NOT exist any correct comparator )
    and finally --> closed pieces ( in any order ) 
    and the sequence remains correct
    But the issue is that NOT exist any correct comparator for decremental-closed-open pieces, many teams, my team included, accepted this problem with wrong criteries for compare decremental-closed-open pieces,
    for example:
    - decreasing order of pre (My solution)
    - decreasing order of par(pre - sum , sum)
    Both criteries has WRONG SOLUTION to this case:
    4
    (((((
    ))))(
    )))))((((
    )
    The correct idea is that if we have a good way of compare open and incremental-closed-open pieces, then we can divide the problem in two parts:
    1 - for each possible value v, what is the maximum lentgh of any sequence formed using only open and incremental-closed-open pieces, with exactly v open parentheses without couple, this problem can be solved sorting open and incremental-closed-open pieces and doing dp
    2 - for each possible value v, what is the maximum lentgh of any sequence formed using only decremental-closed-open and closed pieces, with exactly v closed parentheses without couple, this problem is similar to 1 if the pieces are reverted and the parentheses are changed '('-->')' and ')'-->'('.
    Now the solution for original problem would be
    Max( dp[v] + dp2[v] ) for all possible value v
    #include <iostream>
    #include <cstring>
    #include <queue>
    using namespace std;
    template <class T, class C>
    using heap = priority_queue<T, vector<T>, C>;
    void abc(string s, int &a, int &b, int &c)
    {
        a = 0,
        b = 0,
        c = s.length();
        for (int i = 0; i < s.length(); i++)
        {
            switch (s[i])
            {
            case '(':
                a++;
                break;
            case ')':
                if (a > 0)
                {
                    a--;
                }
                else
                {
                    b++;
                }
            }
        }
    }
    struct triple
    {
        int a,
            b,
            c;
    };
    bool operator>(const triple &A, const triple &B)
    {
        if (A.b ^ B.b)
        {
            return A.b > B.b;
        }
        if (A.a ^ B.a)
        {
            return A.a < B.a;
        }
        return A.c < B.c;
    }
    bool operator<(const triple &A, const triple &B)
    {
        if (A.a ^ B.a)
        {
            return A.a > B.a;
        }
        if (A.b ^ B.b)
        {
            return A.b < B.b;
        }
        return A.c < B.c;
    }
    int main()
    {
        int n{0};
        cin >> n;
        int A[90001], B[90001];
        memset(A, 0xf0, sizeof(A));
        memset(B, 0xf0, sizeof(B));
        A[0] = 0;
        B[0] = 0;
        heap<triple, greater<triple>> I;
        heap<triple, less<triple>> D;
        for (int i = 1; i <= n; i++)
        {
            string s;
            cin >> s;
            int a{0}, b{0}, c{0};
            abc(s, a, b, c);
            if (a >= b)
            {
                I.push({a, b, c});
            }
            else
            {
                D.push({a, b, c});
            }
        }
        while (I.size())
        {
            const int a = I.top().a,
                      b = I.top().b,
                      c = I.top().c;
            for (int x = 90000; x >= max(b, a - b); x--)
            {
                A[x] = max(A[x], A[x - a + b] + c);
            }
            I.pop();
        }
        while (D.size())
        {
            const int a = D.top().a,
                      b = D.top().b,
                      c = D.top().c;
            for (int x = 90000; x >= max(a, b - a); x--)
            {
                B[x] = max(B[x], B[x - b + a] + c);
            }
            D.pop();
        }
        int reponse{0};
        for (int x = 0; x <= 90000; x++)
        {
            reponse = max(reponse, A[x] + B[x]);
        }
        cout << reponse << endl;
        return 0;
    }
  • 相关阅读:
    多重平行中介(Mplus)
    小米手机,发短信出现闪退
    宇宙是有边还是没边?
    如何查一篇文章的引用文章
    卡方检验
    函数的形参与实参(二维数组)
    输出矩阵四周的数字的平均数(C)
    关于amos 的自由度
    Sql server case when then
    Sql Server中两个表之间数据备份和导入
  • 原文地址:https://www.cnblogs.com/JebediahKerman/p/9742462.html
Copyright © 2011-2022 走看看