一、一個含有n個元素的陣列，找出m個數使其和為K

動態規劃：只能找出一組，O(n^2)

找出所有參考上述；連結

// 列印和為n的組合，動規法，O(n^2)
	public static List<Integer> findSums(int[] a, int n) {
		boolean[] dp = new boolean[n + 1];
		List<Integer>[] list = new ArrayList[101];
		for (int i = 0; i < list.length; i++) {
			list[i] = new ArrayList<>();
		}
		dp[a[0]] = true;
		list[a[0]].add(a[0]);
		for (int i = 1; i < a.length; i++) {
			for (int j = n; j >= a[i]; j--) {
				if (dp[j - a[i]]) {
					dp[j] = true;
					list[j].addAll(list[j - a[i]]);
					list[j].add(a[i]);
				}
			}
			if (dp[n]) {
				break;
			}
		}
		return list[n];
	}
 

二、資料分組

題目描述

小組編號問題。輸入一組數【2,7,3,4,9】，表示第一組有2個人，編號為【1、2】，第二組有7個人編號為【3~9】，第三組有3個人編號為【10~12】，第四組有4個人編號為【13~16】，第五組有9個人編號為【17~25】。

現在求，編號為1、25、11的人分別在哪個組裡。

示例： 
輸入 
5 
2 7 3 4 9 
3 
1 25 11

輸出 
1 5 3

計算累加小組成員數，結合二分查詢，複雜度O( min(n, mlogn) )

public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			int n = sc.nextInt();
			int[] arr = new int[n];
			arr[0] = sc.nextInt();
			for (int i = 1; i < n; i++) {
				arr[i] = arr[i - 1] + sc.nextInt();
			}
			int m = sc.nextInt();
			int query = 0;
			int index = 0;
			for (int i = 0; i < m; i++) {
				query = sc.nextInt();
				index = search(arr, query);
				System.out.print(index + " ");
			}

		}
		sc.close();
	}

	public static int search(int a[], int target) {
		int left = 0;
		int right = a.length - 1;
		int mid = 0;
		while (left < right) {
			mid = left + (right - left) / 2;
			if (target >= a[mid]) {
				left = ++mid;
			} else {
				right = mid;
			}
		}
		return left + 1;
	}
 

三、3個有序陣列查詢第k個

1. 在每一個數組中取出第一個值，然後把它們放在一個大小為3的小根堆中。此步驟的時間複雜度為O(3)

2. 取出堆中的最小值， 然後把該最小值所處的陣列的下一個值放在陣列的第一個位置。此步驟的時間複雜度為O(lg 3).

3. 不斷的重複步驟二，直到去出k個或所有的陣列都為空。

建堆只建一次，複雜度為O(3)；所以為O(3)+O(k*lg 3) = O(k)

	public static int findKth(int[] a, int b[], int c[], int count) {
		PriorityQueue<Integer> s = new PriorityQueue<>();
		int i = 0, j = 0, k = 0;
		s.add(a[i]);
		s.add(b[j]);
		s.add(c[k]);
		while (count > 1) {
			if (s.peek() == a[i]) {
				s.poll();
				if (i + 1 < a.length) {
					s.add(a[++i]);
				}
				count--;
				continue;
			}
			if (s.peek() == b[j]) {
				s.poll();
				if (j + 1 < b.length) {
					s.add(b[++j]);
				}
				count--;
				continue;
			}
			if (s.peek() == c[k]) {
				s.poll();
				if (k + 1 < c.length) {
					s.add(c[++k]);
				}
				count--;
				continue;
			}

		}
		return s.peek();
	}