13

关键就是找出一个人在从左到右处于第几个位置，从右到左处于第几个位置，然后相加减一就是队列里的人数，找出其中最大的，最少要去除的人数就可以得到了。 #include

int main(){

int i,j,n,max,ans;

int high[101];

int F1[101],F2[101];

while(scanf("%d",&n)!=EOF){

for(i=1;i<=n;i++)

scanf("%d",&high[i]);

for(i=1;i<=n;i++){

max=1;

for(j=1;j

if(high[i]>high[j]&&F1[j]+1>max)

max=F1[j]+1;

F1[i]=max;

}

for(i=n;i>=1;i--){

max=1;

for(j=n;j>i;j--)

if(high[i]>high[j]&&F2[j]+1>max)

max=F2[j]+1;

F2[i]=max;

}

ans=101;

for(i=1;i<=n;i++){

if(ans>n-(F1[i]+F2[i]-1))

ans=n-(F1[i]+F2[i]-1);

}

printf("%d\n",ans);

}

return 0;

}

发表于 2018-01-29 19:08:25

回复(0)

11

#include

using namespace std;

int dp1[100];//左边升序

int dp2[100];//右边降序

int s[100];

/*

除第一个和最后一个以外，以每个数为中间数。求此数的左边最大升序子序列的长度dp1[i]，以及右边最长降序子序列的长度dp2[i]

最少出列数应为min( n-dp1[i]-dp2[i] )的值

*/

void fun(int n){

int i,j;

//从前到后，求最长升序

for(i=0;i

for(j=i-1;j>=0;j--){

if(s[j]

dp1[i]=max(dp1[j]+1,dp1[i]);

}

}

//从后往前，求最长降序

for(i=n-1;i>=0;i--){

for(j=i+1;j

if(s[j]

dp2[i]=max(dp2[j]+1,dp2[i]);

}

}

}

int main(){

int n;

while(cin>>n){

int i,j,k;

for(i=0;i

cin>>s[i];

dp1[i]=1;

dp2[i]=1;

}

fun(n);

int min_sum=n-dp1[0]-dp2[0]+1;//重复减了自身两次，故加1

for(k=1;k

if(min_sum>(n-dp1[k]-dp2[k]+1))

min_sum=n-dp1[k]-dp2[k]+1;

}

cout<

}

return 0;

}

发表于 2019-03-15 12:45:10

回复(0)

4

import java.util.Scanner;

public class Main{

public static void main(String[] args){

Scanner in = new Scanner(System.in);

while(in.hasNext()){

int n = in.nextInt();

int[] arr = new int[n];

int[] left = new int[n];

int[] right = new int[n];

for(int i=0;i

arr[i] = in.nextInt();

}

//动态规划

//求最长递增子序列

for(int i=0;i

left[i] = 1;

for(int j=i-1;j>=0;j--)

if(arr[j]

left[i] = Math.max(left[i], left[j]+1);

}

//求从右边数起的最长递减子序列

for(int i=n-1;i>=0;i--){

right[i] = 1;

for(int j=i+1;j

if(arr[i]>arr[j])

right[i] = Math.max(right[i], right[j]+1);

}

int max=0;

for(int i=0;i

max = Math.max(max, left[i]+right[i]-1);

}

System.out.println(n-max);

}

}

}

发表于 2018-02-12 18:18:54

回复(0)

4

/*动态规划的最长子列问题，分别从前往后和从后往前寻找以i点为尾的最长子列，寻找两个子列和的最大值*/

#include

int main()

{

int N,i,j,max;

while(scanf("%d",&N)!=EOF)

{

int high[200],marka[200],markb[200];

for(i=1;i<=N;i++)

{

scanf("%d",&high[i]);

marka[i]=markb[i]=1; /*每点为尾的子列长度最小都为1*/

}

for(i=2;i<=N;i++) /*从前往后寻找以i点为尾的最长递增子列*/

{

max=marka[i];

for(j=i-1;j>=1;j--)

{

if(high[i]>high[j])

max=(max>marka[j]+1)?max:marka[j]+1;

}

marka[i]=max;

}

for(i=N-1;i>=1;i--) /*从后往前寻找以i点为尾的最长递增子列*/

{

max=markb[i];

for(j=i+1;j<=N;j++)

{

if(high[i]>high[j])

max=(max>markb[j]+1)?max:markb[j]+1;

}

markb[i]=max;

}

max=marka[1]+markb[1]; /*寻找点i两个子列和的最大值*/

for(i=2;i<=N;i++)

max=(max>marka[i]+markb[i])?max:marka[i]+markb[i];

printf("%d\n",N-max+1);

}

return 0;

}

发表于 2017-03-09 10:08:59

回复(1)

2

#include

using namespace std;

int num[100];

int dp1[100];

int dp2[100];

int main(){

int count;

while(cin>>count){

for(int i=0;i

cin>>num[i];

}

for(int i=0;i

dp1[i]=1;

for(int j=0;j

if(num[i]>num[j]){

dp1[i]=max(dp1[j]+1,dp1[i]);

}

}

}

for(int i=count-1;i>=0;i--){

dp2[i]=1;

for(int j=count-1;j>i;j--){

if(num[i]>num[j]){

dp2[i]=max(dp2[i],dp2[j]+1);

}

}

}

int total=0;

for(int i=0;i

total=max(dp1[i]+dp2[i]-1,total);

}

cout<

}

} 枚举每个位置，从左边找最长上升子序列，从右边开始找最长下降子序列，两个数相加就是题目所说的唱歌的人数。

发表于 2020-02-01 21:50:20

回复(0)

2

/*

* 思路分析

动态规划求出以每个人结尾的左边和右边的最大队列长度

枚举每个人为“中心点”，计算出满足题目要求的队列长度，记录最大值

我们用left[i]表示从左边起到第i个人结束的最长上升队列的人数，那么得到最优解的结构：left[i] =

max{max(left[k] + 1), 1} 0<=k<=i-1 && a[k] < a[i]

同样用right[i]表示从右边起到第i个人结束的最大上升队列的人数，得到：right[i] =

max{max(right[k] + 1), 1} i + 1 <= k <= n - 1 && a[k]

< a[i]

*/

import java.util.Scanner;

public class Main{

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner in = new Scanner(System.in);

while (in.hasNextInt()) {

int cnt = in.nextInt();

int[] height = new int[cnt];

for (int i = 0; i < cnt; i++) {

height[i] = in.nextInt();

}

System.out.println(processChorusFormation(height, cnt));

}

in.close();

}

private static int processChorusFormation(int[] height, int len) {

// TODO Auto-generated method stub

int res = 0;

int[] left = new int[len];

int[] right = new int[len];

left[0] = right[len - 1] = 1;

for (int i = 1; i < len; i++) {

left[i]=1;

for (int k =0; k

if (height[i] > height[k]) {

left[i] = Math.max(left[i], left[k] + 1);

}

}

}

for (int i = len - 2; i >= 0; i--) {

right[i]=1;

for (int k = len - 1; k > i; k--) {

if (height[i] > height[k]) {

right[i] = Math.max(right[i], right[ k] + 1);

}

}

}

for (int i = 0; i < len; i++) {

if (left[i] + right[i] - 1 > res) {

res = left[i] + right[i] - 1;

}

}

return len-res;

}

}

编辑于 2016-07-29 09:01:22

回复(0)

1

#include

using namespace std;

int dp1[101];

int dp2[101];

int T[101];

int main()

{

int N;

while(cin >> N)

{

for(int i = 0;i

{

cin >> T[i];

}

int maxnum = 0;

for(int i = 0;i

{

dp1[i] = 1;

for(int j = 0;j

{

if(T[i] > T[j])

{

dp1[i] = max(dp1[i],dp1[j] + 1);

}

}

dp2[N - i - 1] = 1;

for(int j = N - 1;j > N - i - 1;j--)

{

if(T[N - i - 1] > T[j])

{

dp2[N - i - 1] = max(dp2[N - i - 1],dp2[j] + 1);

}

}

}

for(int i = 0;i

{

maxnum = max(dp1[i] + dp2[i],maxnum);

}

cout <

}

return 0;

}

发表于 2021-02-08 12:21:25

回复(0)

1

//前后两次运用LIS(最长递增子序列)

//由于合唱队形是先递增后递减

//a数组是输入序列 b数组是a数组的逆序列

//先对a数组求最长递增子序列

//再对b数组求最长递增子序列

//由于合唱队形最后一人到中间最高的人是一个递增序列

//对应的b数组序列就是从第一位开始求递增序列，这里求递增还是递减要想清楚

//想要出列的人最少，那么留下的人就要最多

//每一个队员对应的LISa值的意思是，假设他自己为最高，则他前面有多少人(包括他自己)

//每一个队员对应的LISb值的意思是，假设他自己为最高，则他后面有多少人(包括他自己)

//所以要找留下的人最多的方法是，依次比较每一个队员对应的LISa和LISb的值的和，最大值即为所求

//求出列人数的方法：总人数减去  (max(LISa+LISb)-1)

//因为LISa和LISb加起来时，最高的那个队员被加了两次

#include

int main(){

int n;

int a[101],b[101],LISa[101],LISb[101]={0};

int i,j;

while(scanf("%d",&n)!=EOF){

for(i=0;i

scanf("%d",&a[i]);

b[n-i-1]=a[i];    //b数组是a数组的逆序列

}

//a数组求最长递增子序列

LISa[0]=1;

for(i=1;i

int max=0;

for(j=i-1;j>=0;j--){

if(a[j]

if(LISa[j]>max)

max=LISa[j];

}

}

LISa[i]=max+1;

}

//b数组求最长递增子序列

LISb[0]=1;

for(i=1;i

int max=0;

for(j=i-1;j>=0;j--){

if(b[j]

if(LISb[j]>max)

max=LISb[j];

}

}

LISb[i]=max+1;

}

int result=0;

for(i=0;i

if(LISa[i]+LISb[n-i-1]>result){

result=LISa[i]+LISb[n-i-1];

}

}

printf("%d\n",n-result+1);  //这里是化简后，把括号去了，所以最后是+1

}

}

发表于 2020-07-29 11:46:27

回复(0)

1

//两次dp求正反序的最长递增子序列长度,这样代码比较简洁高效

#include

(720)#include

using namespace std;

const int maxn=105;

int a1[maxn];

int a2[maxn];

int dp1[maxn];//正序以a1[i]为最长递增子序列长度

int dp2[maxn];//逆序以a2[i]为最长递增子序列长度

int main()

{

int n;

while(cin>>n)

{

for(int i=0;i

{

cin>>a1[i];

a2[n-1-i]=a1[i];//逆序

}

for(int i=0;i

{

dp1[i]=1;//初始化为1

dp2[i]=1;

for(int j=0;j

{

if(a1[i]>a1[j])

{

dp1[i]=max(dp1[i],dp1[j]+1);//正序求以a1[i]递增子序列长度

}

if(a2[i]>a2[j])

{

dp2[i]=max(dp2[i],dp2[j]+1);//逆序求以a2[i]递增子序列长度

}

}

}

int ans=0;

for(int i=0;i

{

dp1[i]+=dp2[n-1-i];//相同元素作为末尾的递增子序列长度相加，一个从左到右，一个从右到左

ans=max(ans,dp1[i]);//选出最大的符合要求的长度

}

cout<

}

return 0;

}

发表于 2020-04-07 20:27:31

回复(0)

1

/*

动态规划：求最长先增后减序列的值

用dp[i]来表示以a[i]为结尾的最长递增子序列的值

用dp2[i]来表示以a[i]为开头的最长递减子序列的值

那么最长先增后减序列的值就是

max(ans,dp[i]+dp2[i]-1); 这里要-1，因为在dp和dp2中，a[i]这个数本身被计算了两次

*/

#include

using namespace std;

const int maxn = 110;

int arr[maxn];

int dp[maxn]; // 从左至右最长递增子序列

int dp2[maxn]; // 从右至左最长递减子序列

int main() {

int n;

while(~scanf("%d",&n)) {

for(int i=0; i

scanf("%d",&arr[i]);

dp[i] = 1;

dp2[i] = 1;

}

for(int i=0; i

for(int j=0; j

if(arr[j]

dp[i] = max(dp[i],dp[j]+1);

}

}

}

for(int i=n-1; i>=0; i--) {

for(int j=n-1; j>i; j--) { // 从右到左，求最长递减子序列

if(arr[j]

dp2[i] = max(dp2[j]+1,dp2[i]);

}

}

}

int ans = INT_MAX; // 保存结果

for(int i=0; i

ans = min(ans,n-dp[i]-dp2[i]+1); // 重复减了自身两次

}

printf("%d\n",ans);

}

}

发表于 2020-03-23 22:42:57

回复(0)

1

#include

using namespace std;

int main() {

int n;

while (cin >> n) {

// 从左往右升序DP，dp_asc[i]表示i位置为结束的最长递子序列长度

int dp_asc[n];

// 从左往右降序DP, dp_desc[i]表示以i为结尾的最长递减子序列长度

int dp_desc[n];

int std[n];

for (int i = 0; i

scanf("%d", &std[i]);

}

// 升序DP dp[i] = max{1, dp[j] + 1 | j  std[j]}

for (int i = 0; i

dp_asc[i] = 1;

for (int j = 0; j

if (std[i] > std[j]) {

dp_asc[i] = max(dp_asc[i], dp_asc[j] + 1);

}

}

}

// 降序DP dp[i] = max{1, dp[j] + 1 | j

// 这里从后往前推，注意if判断

for (int i = n - 1; i >=0 ; --i) {

dp_desc[i] = 1;

for (int j = n - 1; j > i ; --j) {

if (std[i] > std[j]) {

dp_desc[i] = max(dp_desc[i], dp_desc[j] + 1);

}

}

}

int maxN = -1;

// 遍历两个DP

for (int i = 0; i

maxN = max(maxN, dp_asc[i] + dp_desc[i] - 1);  // 减去重复计算的i

}

cout <

}

return 0;

}

编辑于 2020-03-14 15:33:28

回复(0)

1

Easy AC! 最大上升子序列的变种。 #include

using namespace std;

int main(){

int n,t[110],maxlen[110],rmaxlen[110];

cin>>n;

fill(maxlen,maxlen+n,1);

fill(rmaxlen,rmaxlen+n,0);

for(int i=0;i>t[i];

for(int i=0;i

for(int j=0;j

if(t[j]

maxlen[i]=max(maxlen[i],maxlen[j]+1);

}

}

}

reverse(t,t+n);

for(int i=0;i

for(int j=0;j

if(t[j]

rmaxlen[i]=max(rmaxlen[i],rmaxlen[j]+1);

}

}

}

for(int i=0;i

cout<

return 0;

}

发表于 2020-03-07 20:05:05

回复(1)

1

两个动态规划，找出左到右递增时最长子序列长度，右到左递增时最长子序列长度。

然后相同下标相加长度相加-1就得到题目要求的队形长度。就可以得到去除的人数 #找出一个方向上的递增子序列长度

def findAscSubString(peopleNum, heightList):

ascSubNum = [1] * peopleNum

for i in range(peopleNum):

if heightList[i] != min(heightList[:i + 1]):

for j in range(i):

if heightList[i] > heightList[j]:

if ascSubNum[i] < ascSubNum[j] + 1:

ascSubNum[i] = ascSubNum[j] + 1

return ascSubNum

#得到去除的队员人数

def findRemovePeople(peopleNum, heightList):

leftPeople = findAscSubString(peopleNum, heightList) #左到右递增

rightPeople = findAscSubString(peopleNum, heightList[::-1]) #右到左递增

rightPeople.reverse() #反转得到下标对应

stayPeople = 0

for i in range(peopleNum):

if stayPeople < leftPeople[i] + rightPeople[i]:

stayPeople = leftPeople[i] + rightPeople[i]

return peopleNum - stayPeople + 1

while True:

try:

peopleNum = int(input())

heightList = list(map(int, input().split()))

print(findRemovePeople(peopleNum, heightList))

except Exception:

break

编辑于 2018-10-01 17:44:44

回复(1)

1

//数队列，从左到右从小到大，然后从右到左从小到大

#include

int max(int a,int b){

if(a>b) return a;

else return b;

}

int main(){

int n;

int stu[100];

int left[100],right[100];

while(scanf("%d",&n)!=EOF){

for(int i=0;i

scanf("%d",&stu[i]);

}

for(int i=0;i

left[i]=1;

right[i]=1;

}

for(int i=1;i

for(int j=0;j

if(stu[i]>stu[j]){

left[i]=max(left[i],left[j]+1);

}

}

}

for(int i=n-2;i>=0;i--){

for(int j=n-1;j>i;j--){

if(stu[i]>stu[j]){

right[i]=max(right[i],right[j]+1);

}

}

}

int MAX=0;

for(int i=0;i

stu[i]=left[i]+right[i];

MAX=max(MAX,stu[i]);

}

printf("%d\n",n-MAX+1);

}

}

发表于 2018-08-22 10:31:03

回复(0)

0

#include

#include

/***

本题就是求最长合唱子序列的长度K，之后再用N-K即可得出最少出列同学数

***/

using namespace std;

const int MAXN=100;

int height[MAXN];

int dp[MAXN];//dp[i]为以height[i]为末尾的最长合唱子序列的长度

int dp2[MAXN];

int MaxSingSeq(int n)

{

int maximum=0;

for(int i=0;i

{

dp[i]=1;

for(int j=0;j

{

if(height[j]

dp[i]=max(dp[i],dp[j]+1);

}

}

for(int i=n-1;i>=0;i--)//从后往前寻找以i点为尾的最长递增子序列，

{                      //注意，不要从前往后寻找最长递减子序列，那样是错的

dp2[i]=1;

for(int j=n-1;j>i;j--)

{

if(height[j]

dp2[i]=max(dp2[i],dp2[j]+1);

}

}

for(int i=0;i

maximum=max(maximum,dp[i]+dp2[i]-1);

return maximum;

}

int main()

{

int n;

while(cin>>n)

{

for(int i=0;i

cin>>height[i];

int answer=MaxSingSeq(n);

cout<

}

return 0;

}

发表于 2021-02-22 20:51:26

回复(0)

0

import java.util.*;

public class Main{

public static void main(String[] args){

int N;

Scanner sc  =new Scanner(System.in);

N = sc.nextInt();

int[] num = new int[N];

int[] pre = new int[N];

int[] post = new int[N];

int max = 0;

for(int i= 0;i

num[i] = sc.nextInt();

}

for(int i =1;i

for(int j = 0;j

if(num[i]>num[j]){

if((pre[j]+1)>pre[i]){

pre[i] = pre[j]+1;

}

}

}

}

for(int i=N-2;i>=0;i--){

for(int j = N-1;j>=i;j-- ){

if(num[i]>num[j]){

if((post[j]+1)>post[i]){

post[i] = post[j]+1;

}

}

}

}

for(int i=0;i

if((pre[i]+post[i])>max) max = pre[i]+post[i];

}

System.out.println(N-max-1);

}

}

发表于 2020-07-09 16:42:04

回复(0)

0

#include

#include

using namespace std;

int n;

int t;

int c[300][2];

const int l = 130;

const int h = 230;

int main() {

while (cin >> n) {

memset(c, 0, sizeof(c));

for (int i = 0; i

cin >> t;

c[t][0] = c[t][1] = 1;

for (int j = l; j <= h; ++j) {

if (j

c[t][0] = max(c[t][0], c[j][0]+1);

} else if (j > t) {

c[t][1] = max(c[t][1], max(c[j][0],c[j][1])+1);

}

}

}

int ans = 0;

for (int i = l; i <= h; ++i) {

ans = max(ans, c[i][0]);

ans = max(ans, c[i][1]);

}

cout <

}

return 0;

}

上面提供了一个非常规思路：O(NR)的DP，数组c的第2维表示双调序列在上升段还是下降段。得益于本题中R非常小(R=230-130=100)，效率和传统的LIS+LDS的O(N^2)的DP差不多。

推广到K调序列中，上述算法的复杂度为O(NRK)，而在K调序列中传统DP的复杂度会变成O(N^K)。

发表于 2020-07-02 20:04:25

回复(0)

0

#include

using namespace std;

const int N = 110;

int dp1[N],dp2[N];

int d[N];

int main(){

int n;

while(cin>>n)

{

for(int i = 0; i

{

cin>>d[i];

dp1[i] = dp2[i] = 1;

}

for(int i = 1 ; i < n; i++)

{

for(int j = 0 ; j < i ; j++)

{

if(d[j] < d[i])

dp1[i] = max(dp1[i],dp1[j] + 1);

}

}

for(int i = n-2 ; i >=0; i --)

{

for(int j = n-1 ; j > i ; j --)

{

if(d[j] < d[i])

dp2[i] = max(dp2[i],dp2[j] + 1);

}

}

int t = -1;

for(int i = 0 ; i < n ; i++)

{

t = max(t,dp1[i] + dp2[i] - 1);

}

cout<< n - t <

}

return 0;

}

发表于 2020-05-11 16:59:00

回复(0)

0

//有一个从起始寻找最长上升序列，一个从最后开始讯号最长上升序列。

#include

(720)#include

#include

using namespace std;

const int maxk=101;

int arr[maxk];

int dip[maxk];

int dip2[maxk];

int dreseq(int k){

for(int i=0;i

dip[i]=1;

for(int j=0;j

if(arr[j]

dip[i]=max(dip[j]+1,dip[i]);

}

}

}

return 0;

}

int incseq(int k){

for(int i=k-1;i>=0;i--){

dip2[i]=1;

for(int j=k-1;j>i;j--){

if(arr[j]

dip2[i]=max(dip2[j]+1,dip2[i]);

}

}

}

return 0;

}

int main(){

int k;

int maxs=0;

while(cin>>k){

for(int i=0;i

cin>>arr[i];

}

dreseq(k);

incseq(k);

for(int i=0;i

maxs=max(maxs,dip[i]+dip2[i]-1);

}

cout<

}

return 0;

}

发表于 2020-05-10 15:28:25

回复(0)

0

#include

using namespace std;

//动态规划,分别寻找从前往后的最长递增子序列以及从后往前的最长递增子序列

const int MAXN = 100;

int arr[MAXN];

int dp1[MAXN];

int dp2[MAXN];

int main(){

int N;

while(cin>>N){

for(int i=0;i

cin>>arr[i];

}

for(int i=0;i

dp1[i] = 1;

for(int j=0;j

if(arr[j]

dp1[i] = max(dp1[i],dp1[j]+1);

}

}

}

for(int i=N-1;i>=0;i--){

dp2[i] = 1;

for(int j=N-1;j>i;j--){

if(arr[j]

dp2[i] = max(dp2[i],dp2[j]+1);

}

}

}

for(int i=0;i

dp1[i] += dp2[i];

}

int max = dp1[0];

for(int i=1;i

if(dp1[i]>max) max=dp1[i];

}

cout<

}

return 0;

}

发表于 2020-05-04 19:05:10

回复(0)