codeforce538D.Flood Fill

You are given a line of n colored squares in a row, numbered from 1 to n from left to right. The i-th square initially has the color ci.

Let’s say, that two squares i and j belong to the same connected component if ci=cj, and ci=ck for all k satisfying i<k<j. In other words, all squares on the segment from i to j should have the same color.

For example, the line [3,3,3] has 1 connected component, while the line [5,2,4,4] has 3 connected components.

The game “flood fill” is played on the given line as follows:

At the start of the game you pick any starting square (this is not counted as a turn).
Then, in each game turn, change the color of the connected component containing the starting square to any other color.

Find the minimum number of turns needed for the entire line to be changed into a single color.

Input
The first line contains a single integer n(1≤n≤5000) — the number of squares.
The second line contains integers c1,c2,…,cn (1≤ci≤5000) — the initial colors of the squares.

Output
Print a single integer — the minimum number of the turns needed.

Examples
Input

4
5 2 2 1

Output

2

Input

8
4 5 2 2 1 3 5 5

Output

4

Input

1
4

Output

0

---

给出一个数组，数组中数字代表颜色，相同数字表示相同的颜色，数组中相同且相邻的颜色称为一个部分。现在可以选择一个部分并改变其颜色，求最少改变几次颜色能将这个数组变为只有一种颜色。

可能在这里会想到一个分治的算法，每次只改变并合并相邻的部分。这样区间的转移方式只有向左或向右，以向右为例，下面说明颜色改变选择：
现有一区间[L,R]，颜色为c，在位置R+1上的颜色为c r+1，且与c不同色

如果改变为除 c 与c r+1之外的颜色，最终结果是数组中部分数-1，改变次数+2；而改为c 或 c r+1二者中的颜色，则仍然是数组部分数-1，但是改变次数+1。在达到相同的结果(相同的部分数),显然后者的改变次数更少，因此变色时，选择合并前两部分的颜色之一，即合并后区间端点在原数组中所代表的颜色。
对于任意一个区间，在保证移动后区间有意义的情况下，每一个区间都有如下可移动方式：

1. 向左移动，合并后区间为左端点颜色
2. 向左移动，合并后区间为右端点颜色
3. 向右移动，合并后区间为左端点颜色
4. 向右移动，合并后区间为右端点颜色

注：2，3两种情况可由其他区间的1，4情况推出
现记dp[L][R][c],其中L,R,表示区间位置，c表示区间颜色，当c为1时，表示区间为右端点颜色；当c为0时，表示区间为左端点颜色。
dp[l-1][r][0]=min(dp[l-1][r][0],dp[l][r][]+if color same)
dp[l][r+1][1]=min(dp[l][r+1][1],dp[l][r][]+if color same)

考虑到迭代所需要的内存空间可能不够，不如改成循环稳一点，因为所给数据中，数组长度最大只有5000，这样所有可能对数组的改动也只有1e6的情况，是可以用dp求解的。
之后，再考虑循环的移动方向。若所有状态都被计算过，且当更新某一状态时，随后能更新此状态下导出的所有状态，那么得出的答案便一定是最优的。
如果左端点与右端点都是从左向右遍历，那么更新了dp[3][4]不会更新由此导出的dp[2][4],因此是不正确的；
如果左端点向左，右端点向右，貌似可以耶( •̀ ω •́ )y
如果左端点向右，右端点向右，这样更新了dp[1][2]不可以更新dp[1][5],此方法不可行；
如果左端点向右，右端点向左，现在更新了dp[3][5]不可以更新由此导出的dp[1][5]，此方法不可行。

Ps:若能保证所有导致当前状态前置状态能被遍历，那么再条用当前状态时，当前状态一定是所求问题最优状态。但并不是所有dp都需要这样求解，这只是最优，但不是必要的。保证 所有状态都被遍历并更新与更新状态有关的状态才 是必要的。

---

#include <stdio.h>
#include <climits>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <utility>
#include <vector>
#include <string>
#define INF 0x3f3f3f3f
#define ll long long
#define re return
#define Pair pair<int,int>
#define Make(a,b) make_pair(a,b)
#define Push(num) push_back(num)
#define rep(index,star,finish) for(register int index=star;index<finish;index++)
#define drep(index,finish,star) for(register int index=finish;index>=star;index--)
using namespace std;

int n;
int store[5096];
int dp[5096][5096][2];
int main(){
    ios::sync_with_stdio(false);

    cin>>n;
    rep(i,1,n+1)
        cin>>store[i];

    //ini
    rep(i,1,n+1)
        rep(j,1,n+1)
            dp[i][j][0]=dp[i][j][1]=(i==j ? 0:INF);

    rep(r,1,n+1){
        drep(l,r,1){
            rep(it,0,2){
                int c= (it==0 ? store[l]:store[r]);

                if(l>=2)
                    dp[l-1][r][0]=min(dp[l-1][r][0],dp[l][r][it]+int(c!=store[l-1]));
                if(r+1<=n)
                    dp[l][r+1][1]=min(dp[l][r+1][1],dp[l][r][it]+int(c!=store[r+1]));
            }
        }
    }

    cout<<min(dp[1][n][1],dp[1][n][0])<<endl;
    re 0;
}