LeetCode OJ - Subsets 1 && 2

这道题的做法,一定得掌握啊!!!  elegant & beautiful & concise

下面是AC代码:


 1  /**
2 * Given a set of distinct integers, S, return all possible subsets.
3 * 这道题的做法应该要记住!!!!!
4 * @param s
5 * @return
6 */
7 public ArrayList<ArrayList<Integer>> subsets(int[] s){
8 ArrayList<ArrayList<Integer>> r = new ArrayList<ArrayList<Integer>>();
9 Arrays.sort(s);
10 ArrayList<Integer> sub = new ArrayList<Integer>();
11 r.add(sub);
12 for(int e : s){
13 int cur_size = r.size();
14 for(int j=0;j<cur_size;j++){
15 sub = new ArrayList<Integer>();
16 sub.addAll(r.get(j));
17 sub.add(e);
18 r.add(sub);
19 }
20 }
21 return r;
22 }
23 /**
24 * Given a collection of integers that might contain duplicates, S, return all possible subsets.
25 * @param num
26 * @return
27 */
28 public ArrayList<ArrayList<Integer>> subsetsWithDup(int[] num) {
29 ArrayList<ArrayList<Integer>> r = new ArrayList<ArrayList<Integer>>();
30 Arrays.sort(num);
31 int last = Integer.MAX_VALUE;
32 int mark = 0;
33 ArrayList<Integer> sub = new ArrayList<Integer>();
34 r.add(sub);
35 for(int e:num){
36 int cur_size = r.size();
37 int begin = e==last? mark:0;
38 for(int i = begin;i<cur_size;i++){
39 sub = new ArrayList<Integer>();
40 sub.addAll(r.get(i));
41 sub.add(e);
42 r.add(sub);
43 }
44 last = e;
45 mark = cur_size;
46 }
47 return r;
48 }

LeetCode OJ - Subsets 1 && 2,布布扣,bubuko.com

时间: 2024-10-06 00:45:38

LeetCode OJ - Subsets 1 && 2的相关文章

LeetCode OJ - Sum Root to Leaf Numbers

这道题也很简单,只要把二叉树按照宽度优先的策略遍历一遍,就可以解决问题,采用递归方法越是简单. 下面是AC代码: 1 /** 2 * Sum Root to Leaf Numbers 3 * 采用递归的方法,宽度遍历 4 */ 5 int result=0; 6 public int sumNumbers(TreeNode root){ 7 8 bFSearch(root,0); 9 return result; 10 } 11 private void bFSearch(TreeNode ro

LeetCode OJ - Longest Consecutive Sequence

这道题中要求时间复杂度为O(n),首先我们可以知道的是,如果先对数组排序再计算其最长连续序列的时间复杂度是O(nlogn),所以不能用排序的方法.我一开始想是不是应该用动态规划来解,发现其并不符合动态规划的特征.最后采用类似于LRU_Cache中出现的数据结构(集快速查询和顺序遍历两大优点于一身)来解决问题.具体来说其数据结构是HashMap<Integer,LNode>,key是数组中的元素,所有连续的元素可以通过LNode的next指针相连起来. 总体思路是,顺序遍历输入的数组元素,对每个

LeetCode OJ - Surrounded Regions

我觉得这道题和传统的用动规或者贪心等算法的题目不同.按照题目的意思,就是将被'X'围绕的'O'区域找出来,然后覆盖成'X'. 那问题就变成两个子问题: 1. 找到'O'区域,可能有多个区域,每个区域'O'都是相连的: 2. 判断'O'区域是否是被'X'包围. 我采用树的宽度遍历的方法,找到每一个'O'区域,并为每个区域设置一个value值,为0或者1,1表示是被'X'包围,0则表示不是.是否被'X'包围就是看'O'区域的边界是否是在2D数组的边界上. 下面是具体的AC代码: class Boar

LeetCode OJ - Convert Sorted Array/List to Binary Search Tree

虚函数使用的时机 为什么虚函数不总是适用? 1. 虚函数有事会带来很大的消耗: 2. 虚函数不总是提供所需的行为: 3. 当我们不考虑继承当前类时,不必使用虚函数. 必须使用虚函数的情况: 1. 当你想删除一个表面上指向基类对象,实际却是指向派生类对象的指针,就需要虚析构函数. LeetCode OJ - Convert Sorted Array/List to Binary Search Tree,布布扣,bubuko.com LeetCode OJ - Convert Sorted Arra

LeetCode OJ:Pascal&#39;s Triangle(帕斯卡三角)

Given numRows, generate the first numRows of Pascal's triangle. For example, given numRows = 5,Return [ [1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1] ] 帕斯卡三角,很简单的问题,见代码: 1 class Solution { 2 public: 3 vector<vector<int>> generate(int numRows) {

LeetCode --- 90. Subsets II

题目链接:Subsets II Given a collection of integers that might contain duplicates, S, return all possible subsets. Note: Elements in a subset must be in non-descending order. The solution set must not contain duplicate subsets. For example, If S = [1,2,2]

LeetCode OJ Linked List: 138题、109题和191题

138题:Copy List with Random Pointer 题目分析: 本题思路1:第一步,你需要遍历一下链表,对于每个结点,你都new出一个连接在其后面.第二步,调整random指针.第三步,把复制的链表与原链表断开.时间复杂度O(N),空间复杂度O(1). 本题思路2:第一步,仍需要遍历一下链表,对于每个结点都new出一个节点,但不连接在其后面,把这种旧节点到新结点的映射关系,存储在map中.第二步,调整random指针.时间复杂度O(N),空间复杂度O(N). 本题思路3:第一步

LeetCode OJ平台上Maximum Subarray题目O(n)复杂度解决方案

原始题目如下,意为寻找数组和最大的子串,返回这个最大和即可. Find the contiguous subarray within an array (containing at least one number) which has the largest sum. For example, given the array [?2,1,?3,4,?1,2,1,?5,4], the contiguous subarray [4,?1,2,1] has the largest sum = 6.

LeetCode OJ - Binary Tree Level Order Traversal 1 &amp;&amp; 2

BFS以及它的扩展,我发现栈是个很好用的数据结构,特别是对于顺序需要颠倒的时候!!! 这里有个重要的信息:可以用null来标识一个level的结束!!! 下面是AC代码: 1 /** 2 * Given a binary tree, return the bottom-up level order traversal of its nodes' values. 3 * (ie, from left to right, level by level from leaf to root). 4 *