2017 滴滴

某餐馆有n张桌子，每张桌子有一个参数：a 可容纳的最大人数； 有m批客人，每批客人有两个参数:b人数，c预计消费金额。 在不允许拼桌的情况下，请实现一个算法选择其中一部分客人，使得总预计消费金额最大 

输入描述:

输入包括m+2行。
第一行两个整数n(1 <= n <= 50000),m(1 <= m <= 50000)
第二行为n个参数a,即每个桌子可容纳的最大人数,以空格分隔,范围均在32位int范围内。
接下来m行，每行两个参数b,c。分别表示第i批客人的人数和预计消费金额,以空格分隔,范围均在32位int范围内。

输出描述:

输出一个整数,表示最大的总预计消费金额

输入例子1:

3 5
2 4 2
1 3
3 5
3 7
5 9
1 10

输出例子1:

20

排序，然后按照贪心的思路来，优先排消费金额大的，但是用最小的桌子

找刚好容下的最小桌子时：直接遍历会超时，得用二分

package l2;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeMap;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), m = sc.nextInt();
		int[] a = new int[n];
		for(int i=0; i<n; i++)	a[i]=sc.nextInt();
		int[][] b = new int[m][2];
		for(int i=0; i<m; i++)	{
			b[i][0]=sc.nextInt();
			b[i][1]=sc.nextInt();
		}
		
		Arrays.sort(a);
		
		Arrays.sort(b, new Comparator<int[]>(){
			@Override
			public int compare(int[] o1, int[] o2) {
				return o2[1]-o1[1];
			}
		});
		
		TreeMap<Integer, Integer> s = new TreeMap<Integer, Integer>();
		for(int i : a)
			if(s.containsKey(i))	s.put(i, 1+s.get(i));
			else	s.put(i, 1);
		
		long ret = 0;
		for(int i=0; i<m; i++) {
			Integer t = s.ceilingKey(b[i][0]);
			if(t != null) {
				ret += b[i][1];
				s.put(t, s.get(t)-1);
				if(s.get(t) == 0)	s.remove(t);
			}
		}
		
		System.out.println(ret);
	}
}

小青蛙有一天不小心落入了一个地下迷宫,小青蛙希望用自己仅剩的体力值P跳出这个地下迷宫。为了让问题简单,假设这是一个n*m的格子迷宫,迷宫每个位置为0或者1,0代表这个位置有障碍物,小青蛙达到不了这个位置;1代表小青蛙可以达到的位置。小青蛙初始在(0,0)位置,地下迷宫的出口在(0,m-1)(保证这两个位置都是1,并且保证一定有起点到终点可达的路径),小青蛙在迷宫中水平移动一个单位距离需要消耗1点体力值,向上爬一个单位距离需要消耗3个单位的体力值,向下移动不消耗体力值,当小青蛙的体力值等于0的时候还没有到达出口,小青蛙将无法逃离迷宫。现在需要你帮助小青蛙计算出能否用仅剩的体力值跳出迷宫(即达到(0,m-1)位置)。 

输入描述:

输入包括n+1行:

第一行为三个整数n,m(3 <= m,n <= 10),P(1 <= P <= 100)

接下来的n行:

每行m个0或者1,以空格分隔

输出描述:

如果能逃离迷宫,则输出一行体力消耗最小的路径,输出格式见样例所示;如果不能逃离迷宫,则输出"Can not escape!"。
测试数据保证答案唯一

输入例子1:

4 4 10
1 0 0 1
1 1 0 1
0 1 1 1
0 0 1 1

输出例子1:

[0,0],[1,0],[1,1],[2,1],[2,2],[2,3],[1,3],[0,3]

/*
 * BFS 的时候更新dp
 * 先到达的一定是更小的
 */
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), m = sc.nextInt(), p = sc.nextInt();
		int[][] a = new int[n][m];
		for(int i=0; i<n; i++)
			for(int j=0; j<m; j++)
				a[i][j] = sc.nextInt();
		
		int[][] dir = new int[][]{{0,1,1},{0,-1,1},{1,0,0},{-1,0,3}};
		int[][] dp = new int[n][m];
		for(int i=0; i<n; i++)	Arrays.fill(dp[i], -1);
		dp[0][0] = p;
		Queue<int[]> q = new LinkedList<int[]>();
		Queue<int[]> qq= new LinkedList<int[]>();
		q.add(new int[]{0, 0});
		
		while(!q.isEmpty()) {
			while(!q.isEmpty()) {
				int[] t = q.remove();
				for(int i=0; i<4; i++) {
					int x = t[0]+dir[i][0], y = t[1]+dir[i][1];
					if(x<0||y<0||x>=n||y>=m)	continue;
					if(dp[x][y] == -1 && a[x][y] == 1) {
						qq.add(new int[]{x, y});
						dp[x][y] = dp[t[0]][t[1]] - dir[i][2];
					}
				}
			}
			
			q = qq;
			qq = new LinkedList<int[]>();
		}
		
		if(dp[0][m-1] < 0) {
			System.out.println("Can not escape!");
		} else {
			List<int[]> path = new ArrayList<int[]>();
			path.add(new int[]{0, m-1});
			while(true) {
				int[] t = path.get(path.size()-1);
				for(int i=0; i<4; i++) {
					int x = t[0]-dir[i][0], y = t[1]-dir[i][1];
					if(x<0||y<0||x>=n||y>=m)	continue;
					if(dp[x][y]!=-1 && dp[x][y]-dir[i][2]==dp[t[0]][t[1]]) {
						path.add(new int[]{x, y});
						break;
					}
				}
				
				if(t[0] == 0 && t[1] == 0)	break;
			}
			
			for(int i=path.size()-1; i>0; i--) {
				int[] at = path.get(i);
				System.out.print("["+at[0]+","+at[1]+"]"+",");
			}
			System.out.println("[0,"+(m-1)+"]");
		}
		
	}
}

输入一个正整数n,求n!(即阶乘)末尾有多少个0？ 比如: n = 10; n! = 3628800,所以答案为2 

输入描述:

输入为一行，n(1 ≤ n ≤ 1000)

输出描述:

输出一个整数,即题目所求

输入例子1:

10

输出例子1:

2

package l4;


import java.util.Scanner;

/*
 * 求5的多少次幂
 * 5的倍数 + 25的倍数（算2次） + 125的倍数（算3次）
 */
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		
		int ret = 0;
		while(n > 0) {
			n /= 5;
			ret += n;
		}
		
		System.out.println(ret);
	}
}

给定一个有n个正整数的数组A和一个整数sum,求选择数组A中部分数字和为sum的方案数。
当两种选取方案有一个数字的下标不一样,我们就认为是不同的组成方案。 

输入描述:

输入为两行:

第一行为两个正整数n(1 ≤ n ≤ 1000)，sum(1 ≤ sum ≤ 1000)

第二行为n个正整数A[i](32位整数)，以空格隔开。

输出描述:

输出所求的方案数

输入例子1:

5 15
5 5 10 2 3

输出例子1:

4

思路：最开始DFS + 逆序排序优化，仍然TLE，

只能用DP了，想想DP也不是很难写出来

/*
 * DP
 */
public class Main {
	
	static int ret = 0;
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), m = sc.nextInt();
		int[] a = new int[n];
		long sum = 0;
		for(int i=0; i<n; i++)	{
			a[i]=sc.nextInt();
			sum += a[i];
		}
		if(sum < m) {
			System.out.println(0);
			return;
		}
		
		// dp[i][j]表示到第i位的时候，累加和为j的个数
		long[][] dp = new long[n][m+1];
		dp[0][0] = 1;
		if(a[0] <= m) dp[0][a[0]] = 1;
		for(int i=1; i<n; i++)
			for(int j=0; j<=m; j++) {
				if(j >= a[i])
					dp[i][j] = dp[i-1][j] + dp[i-1][j-a[i]];
				else
					dp[i][j] = dp[i-1][j];
			}
		
		System.out.println(dp[n-1][m]);
	}
}