Codeforces Gym 101623A - 动态规划

题目传送门

　　传送门

题目大意

　　给定一个长度为$n$的序列，要求划分成最少的段数，然后将这些段排序使得新序列单调不减。

　　考虑将相邻的相等的数缩成一个数。

　　假设没有分成了$n$段，考虑最少能够减少多少划分。

　　我们将这个序列排序，对于权值相同的一段数可以任意交换它们，每两个相邻数在原序列的位置中如果是$i, i + 1$，那么划分的段数就可以减少1.

　　每次转移我们考虑添加值相同的一段。

　　每次转移能不能将减少的段数加一取决于当前考虑的数在前一段内有没有出现以及有没有作为最左端点。

　　因此我们记录一个决策与最优解不同的次优解就能转移了。

Code

 /**
  * Codeforces
  * Gym#101623A
  * Accepted
  * Time: 171ms
  * Memory: 18300k
  */
 #include <algorithm>
 #include <iostream>
 #include <cassert>
 #include <cstdlib>
 #include <cstdio>
 using namespace std;
 typedef bool boolean;

 #define pii pair<int, int>
 #define fi first
 #define sc second

 ostream& operator << (ostream& out, pii x) {
     out << "(" << x.fi << ", " << x.sc << ")";
     return out;
 }

 template <typename T>
 void pfill(T* pst, const T* ped, T val) {
     for ( ; pst != ped; *(pst++) = val);
 }

 template <typename T>
 void pcopy(T* pst, const T* ped, T *pval) {
     for ( ; pst != ped; *(pst++) = *(pval++));
 }

 int n;
 int *ar;
 pii *ps;

 inline void init() {
     scanf("%d", &n);
     ar = new int[(n + )];
     for (int i = ; i <= n; i++)
         scanf("%d", ar + i);
 }

 int *ss, *st;
 boolean *exi;
 inline void solve() {
     ps = new pii[(n + )];
     ss = new int[(n + )];
     st = new int[(n + )];
     exi = new boolean[(n + )];
     pfill(exi, exi + n + , false);
     int m = , diff = ;
     for (int i = ; i <= n; i++)
         if (i ==  || ar[i] != ar[i - ])
             ps[++m] = pii(ar[i], ++diff);
     sort(ps + , ps + (n = m) + );
 //    for (int i = 1; i <= m; i++)
 //        cerr << ps[i] << endl;
     ss[] = ;
     for (int i = ; i <= n; i++)
         ss[i] =    ((ps[i - ].first == ps[i].first) ? (ss[i - ]) : (i));
     st[n] = n;
     for (int i = n - ; i; i--)
         st[i] = ((ps[i + ].first == ps[i].first) ? (st[i + ]) : (i));

     ss[] = st[] = ;
     pii f(, -), g(-, -), cf(-, -), cg(-, -);
     for (int i = ; i <= n; i++) {
         if (ss[i] != i)
             continue;
         for (int j = max(ss[i - ], ); j <= st[i - ]; j++)
             exi[ps[j].second] = true;
         for (int j = ss[i], x, uval; j <= st[i]; j++) {
             x = ps[j].second;
             if (exi[x - ]) {
                 if (x -  == f.second && st[i - ] > ss[i - ])
                     assert(x -  != g.second), uval = g.first + ;
                 else
                     uval = f.first + ;
                 uval = max(uval, f.first);
             } else
                 uval = f.first;
             if (uval > cf.first)
                 cg = cf, cf = pii(uval, x);
             else if (x != cg.second && uval > cg.first)
                 cg = pii(uval, x);
         }
         for (int j = max(ss[i - ], ); j <= st[i - ]; j++)
             exi[ps[j].second] = false;
         swap(cf, f);
         swap(cg, g);
         cf = pii(-, -), cg = pii(-, -);
 //        cerr << f << " " << g << endl;
     }
     printf("%d\n", n - f.first - );
 }

 int main() {
     init();
     solve();
     return ;
 }