洛谷-【动态规划】-P2896 [USACO08FEB]一起吃饭Eating Together

题目描述

The cows are so very silly about their dinner partners. They have organized themselves into three groups (conveniently numbered 1, 2, and 3) that insist upon dining together. The trouble starts when they line up at the barn to enter the feeding area.

Each cow i carries with her a small card upon which is engraved Di (1 ≤ Di ≤ 3) indicating her dining group membership. The entire set of N (1 ≤ N ≤ 30,000) cows has lined up for dinner but it's easy for anyone to see that they are not grouped by their dinner-partner cards.

FJ's job is not so difficult. He just walks down the line of cows changing their dinner partner assignment by marking out the old number and writing in a new one. By doing so, he creates groups of cows like 111222333 or 333222111 where the cows' dining groups are sorted in either ascending or descending order by their dinner cards.

FJ is just as lazy as the next fellow. He's curious: what is the absolute mminimum number of cards he must change to create a proper grouping of dining partners? He must only change card numbers and must not rearrange the cows standing in line.

FJ的奶牛们在吃晚饭时很傻。他们把自己组织成三组（方便编号为1, 2和3），坚持一起用餐。当他们在谷仓排队进入喂食区时，麻烦就开始了。

每头奶牛都随身带着一张小卡片，小卡片上刻的是Di（1≤Di≤3）表示她属于哪一组。所有的N（1≤N≤30000）头奶牛排队吃饭，但他们并不能按卡片上的分组站好。

FJ的工作并不是那么难。他只是沿着牛的路线走下去，把旧的号码标出来，换上一个新的。通过这样做，他创造了一群奶牛，比如111222333或333222111，奶牛的就餐组按他们的晚餐卡片按升序或降序排列。

FJ就像任何人一样懒惰。他很好奇：怎样他才能进行适当的分组，使得他只要修改最少次数的数字？由于奶牛们已经很长时间没有吃到饭了，所以“哞哞”的声音到处都是，FJ只好更换卡号，而不能重新排列已经排好队的奶牛。

输入输出格式

输入格式：

* Line 1: A single integer: N

* Lines 2..N+1: Line i describes the i-th cow's current dining group with a single integer: Di

• 第1行：一个整数：n

• 第2~n+1行：第i-1行描述第i个奶牛目前分组。

输出格式：

* Line 1: A single integer representing the minimum number of changes that must be made so that the final sequence of cows is sorted in either ascending or descending order

一个整数，表示必须做出的最小变化数，以便以升序或降序排序最终序列。

 

输入输出样例

输入样例#1： 复制

5
1
3
2
1
1

输出样例#1： 复制

1

题解：本题找的是最小变化数，那如果找到最长的递增或递减序列，剩下的不就是最小的变化数了，最长递增递减序列很好用动规很好实现，但可惜的是On2的时间复杂度对本题来说有一组数据会超时，所以只好降低时间复杂度了，On2往下降就是Onlogn或者是On了，想到Onlogn有没有想到二分，呵呵，没错，这里就是使用的二分找到最长的递增、递减序列，并记录最小的变化数。可以参考我之前写的一篇博客 递增

超时写法：

import java.util.*;
/*
 *一起吃饭
 */
public class Main{
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[] a=new int[n+1];
        for(int i=1;i<=n;i++) {
        	a[i]=in.nextInt();
        }
        int[] d=new int[n+1];
        int[] p=new int[n+1];
        int max=0,max1=0,max2=0;
        for(int i=1;i<=n;i++) {
        	d[i]=1;p[i]=1;
        	for(int j=1;j<i;j++) {
        		if(a[i]>=a[j]) {
        			d[i]=Math.max(d[i], d[j]+1);
        		}
        		if(a[i]<=a[j]) {
        			p[i]=Math.max(p[i], p[j]+1);
        		}
        	}
        	max1=Math.max(max1, d[i]);
        	max2=Math.max(max2, p[i]);
        	max=Math.max(max1, max2);
        }
        System.out.println(n-max);
    }
}

二分解法：

import java.util.*;
/*
 *一起用餐吧
 */
public class Main{
    static int ns=1,ns1=1;
    static int[] s;
    static int[] s1;
    public static int bf(int x) {
    	int l=1,r=ns;
    	while(l<r) {
    		int mid=(l+r)/2;
    		if(s[mid]<x) {
    			r=mid;
    		}else
    			l=mid+1;
    	}
    	return l;
    }  
    public static int bf1(int x) {
    	int l=1,r=ns1;
    	while(l<r) {
    		int mid=(l+r)/2;
    		if(s1[mid]>x) {
    			r=mid;
    		}else
    			l=mid+1;
    	}
    	return l;
    }
	public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[] a=new int[n+1];
        for(int i=1;i<=n;i++) {
        	a[i]=in.nextInt();
        }
        s=new int[n+1];
        s[1]=a[1];
        int  res=0;		//用来记录在最长递增序列中需要变化的数
        for(int i=2;i<=n;i++) {
        	if(s[ns]<a[i]) {
        		s[bf(a[i])]=a[i];
        		res++;
        	}else
        		s[++ns]=a[i];
        }
        s1=new int[n+1];
        s1[1]=a[1];
        int  res1=0;	//用来记录在最长递减序列中需要变化的数
        for(int i=2;i<=n;i++) {
        	if(s1[ns1]>a[i]) {
        		s1[bf1(a[i])]=a[i];
        		res1++;
        	}else
        		s1[++ns1]=a[i];
        }
        System.out.println(Math.min(res, res1));
    }
}