搜狐2018

给定一个十进制的正整数number，选择从里面去掉一部分数字，希望保留下来的数字组成的正整数最大。 

输入描述:

输入为两行内容，第一行是正整数number，1 ≤ length(number) ≤ 1000。第二行是希望去掉的数字数量cnt 1 ≤ cnt < length(number)。

输出描述:

输出保留下来的结果。

示例1

输入

325
1

输出

35

思路：好像在LC见过，额，还是对LC不熟啊！

最开始想用优先队列，遍历到每次到必须去掉一个数的时候，就弹出一个最小的值

package l1;


import java.util.Comparator;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Set;

/*
 * 好像在LC见过，额，还是对LC不熟啊
 * 
 * 删除最小的，最后剩下的不一定是最大的
 * 比如231删除1个
 */
public class WA {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), m = sc.nextInt();
		final String s = ""+n;
		final char[] cs = s.toCharArray();
		PriorityQueue<Integer> pq = new PriorityQueue<Integer>(cs.length, new Comparator<Integer>(){
			public int compare(Integer o1, Integer o2) {
				String t1 = s.substring(0, o1) + s.substring(o1+1);
				String t2 = s.substring(0, o2) + s.substring(o2+1);
				return t2.compareTo(t1);
//				if(cs[o1] == cs[o2])	return o1-o2;
//				return cs[o1]-cs[o2];
			}
		});
		// int[] delete = new int[m];
		Set<Integer> delete = new HashSet<Integer>();
		int p = 0;
		for(; p<cs.length-m+1; p++)	pq.add(p);
		for(int i=1; i<=m; i++) {
			delete.add(pq.remove());	// s需要动态更新才行
			if(p < cs.length)	pq.add(p++);
		}
		
		StringBuilder sb = new StringBuilder();
		for(int i=0; i<cs.length; i++) {
			if(!delete.contains(i))
				sb.append(cs[i]);
		}
		
		System.out.println(sb);
	}
}

这种想法其实是错的，考虑：231删除1个

那就写个递归版本的

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), m = sc.nextInt();
		if(m < 0) m = 0;	
		System.out.println(max(""+n, m));
	}

	public static String max(String s, int m) {
		if(m == 0)	return s;
		String ret = max(s.substring(1), m-1);
		for(int i=1; i<s.length(); i++) {
			String t = s.substring(0, i) + s.substring(i+1);
			String tt = max(t, m-1);
			if(tt.compareTo(ret) > 0)
				ret = tt;
		}
		return ret;
	}
}

OJ上提交不过。。。估计是case有问题，有时间在LC找一下原题

有一条彩色宝石项链，是由很多种不同的宝石组成的，包括红宝石，蓝宝石，钻石，翡翠，珍珠等。有一天国王把项链赏赐给了一个学者，并跟他说，你可以带走这条项链，但是王后很喜欢红宝石，蓝宝石，紫水晶，翡翠和钻石这五种，我要你从项链中截取连续的一小段还给我，这一段中必须包含所有的这五种宝石，剩下的部分你可以带走。如果无法找到则一个也无法带走。请帮助学者找出如何切分项链才能够拿到最多的宝石。 

输入描述:

我们用每种字符代表一种宝石，A表示红宝石，B表示蓝宝石，C代表紫水晶，D代表翡翠，E代表钻石，F代表玉石，G代表玻璃等等，我们用一个全部为大写字母的字符序列表示项链的宝石序列，注意项链是首尾相接的。每行代表一种情况。

输出描述:

输出学者能够拿到的最多的宝石数量。每行一个

示例1

输入

ABCYDYE
ATTMBQECPD

输出

1
3

思路：经典sliding window，环形就复制一份原字符串

package l2;


import java.util.Arrays;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while(sc.hasNext()) {
			String s  =sc.nextLine();
			s = s + s;
			char[] cs = s.toCharArray();
			int[] need = new int[5];
			Arrays.fill(need, 1);
			
			int q = 0, p = 0, realNeed = 5, min = -1;
			for(; p<cs.length; p++) {
				if(cs[p]-'A'<5)	{
					if(need[cs[p]-'A'] > 0)	realNeed--;
					need[cs[p]-'A']--;
				}
				if(realNeed == 0)	break;
			}
			min = p-q+1;
			
			while(p < cs.length) {
				while(realNeed <= 0) {
					min = Math.min(min, p-q+1);
					if(cs[q]-'A'<5) {
						need[cs[q]-'A']++;
						if(need[cs[q]-'A'] > 0) {
							realNeed ++;
						}
					}
					q ++;
				}
				
				while(realNeed > 0) {
					p ++;
					if(p == cs.length)	break;
					if(cs[p]-'A'<5) {
						need[cs[p]-'A']--;
						if(need[cs[p]-'A'] >= 0) {
							realNeed --;
							break;
						}
					}
				}
			}
			
			System.out.println(s.length()/2-min);
		}
	}
}

一只袋鼠要从河这边跳到河对岸，河很宽，但是河中间打了很多桩子，每隔一米就有一个，每个桩子上都有一个弹簧，袋鼠跳到弹簧上就可以跳的更远。每个弹簧力量不同，用一个数字代表它的力量，如果弹簧力量为5，就代表袋鼠下一跳最多能够跳5米，如果为0，就会陷进去无法继续跳跃。河流一共N米宽，袋鼠初始位置就在第一个弹簧上面，要跳到最后一个弹簧之后就算过河了，给定每个弹簧的力量，求袋鼠最少需要多少跳能够到达对岸。如果无法到达输出-1 

输入描述:

输入分两行，第一行是数组长度N (1 ≤ N ≤ 10000)，第二行是每一项的值，用空格分隔。

输出描述:

输出最少的跳数，无法到达输出-1

示例1

输入

5
2 0 1 1 1

输出

4

思路：LC原题，但是忘记最优解法，写了个O(N^2)的DP

/*
 * LC某题的变形，看来LC真的很重要
 */
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] a = new int[n];
		for(int i=0; i<n; i++)a[i]=sc.nextInt();
		
		int[] dp = new int[1+n];
		Arrays.fill(dp, 1, n+1, Integer.MAX_VALUE);
		for(int i=1; i<=n; i++) {
			if(i!=n && a[i] == 0)	continue;
			for(int j=0; j<i; j++) {
				if(dp[j] != Integer.MAX_VALUE && j+a[j]>=i)
					dp[i] = Math.min(dp[i], dp[j]+1);
			}	
			if(dp[i] == Integer.MAX_VALUE) {
				System.out.println(-1);
				return;
			}
		}
		
		System.out.println(dp[n]);
	}
}