Richardo92
Richardo92

Leetcode - 刷题总结3

second round leetcode
57,
Insert Interval (Done)

/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public List insert(List intervals, Interval newInterval) {
        List ret = new ArrayList();
        int i = 0;
        for (; i < intervals.size(); i++) {
            if (intervals.get(i).end < newInterval.start) {
                ret.add(intervals.get(i));
            }
            else {
                break;
            }
        }
        
        for (; i < intervals.size(); i++) {
            if (intervals.get(i).start > newInterval.end) {
                break;
            }
            else {
                newInterval.start = Math.min(newInterval.start, intervals.get(i).start);
                newInterval.end = Math.max(newInterval.end, intervals.get(i).end);
            }
        }
        
        ret.add(newInterval);
        for (; i < intervals.size(); i++) {
            ret.add(intervals.get(i));
        }
        
        return ret;
    }
}

381,
Insert Delete GetRandom O(1) - Duplicates allowed (Done)

public class RandomizedCollection {
    Map> map;
    List list;
    Random r;
    /** Initialize your data structure here. */
    public RandomizedCollection() {
        map = new HashMap>();
        list = new ArrayList();
        r = new Random();
    }
    
    /** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
    public boolean insert(int val) {
        if (!map.containsKey(val)) {
            map.put(val, new HashSet());
            map.get(val).add(list.size());
            list.add(val);
            return true;
        }
        else {
            map.get(val).add(list.size());
            list.add(val);
            return false;
        }
    }
    
    /** Removes a value from the collection. Returns true if the collection contained the specified element. */
    public boolean remove(int val) {
        if (!map.containsKey(val)) {
            return false;
        }
        else {
            int index = map.get(val).iterator().next();
            map.get(val).remove(index);
            if (map.get(val).size() == 0) {
                map.remove(val);
            }
            if (index < list.size() - 1) {
                list.set(index, list.get(list.size() - 1));
                map.get(list.get(list.size() - 1)).remove(list.size() - 1);
                map.get(list.get(list.size() - 1)).add(index);
            }
            list.remove(list.size() - 1);
            return true;
        }
    }
    
    /** Get a random element from the collection. */
    public int getRandom() {
        return list.get(r.nextInt(list.size()));
    }
}

/**
 * Your RandomizedCollection object will be instantiated and called as such:
 * RandomizedCollection obj = new RandomizedCollection();
 * boolean param_1 = obj.insert(val);
 * boolean param_2 = obj.remove(val);
 * int param_3 = obj.getRandom();
 */

4,
Median of Two Sorted Arrays (Done)

public class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if (nums1.length > nums2.length) {
            return findMedianSortedArrays(nums2, nums1);
        }
        
        int m = nums1.length;
        int n = nums2.length;
        int half = (m + n + 1) / 2;
        int begin = 0;
        int end = m;
        while (begin <= end) {
            int i = begin + (end - begin) / 2;
            int j = half - i;
            // nums1[i - 1] and nums2[j]
            if (i > 0 && j < n && nums1[i - 1] > nums2[j]) {
                end = i - 1;
            }
            // nums2[j - 1] and nums1[i]
            else if (j > 0 && i < m && nums2[j - 1] > nums1[i]) {
                begin = i + 1;
            }
            else {
                int left = 0;
                if (i == 0) {
                    left = nums2[j - 1];
                }
                else if (j == 0) {
                    left = nums1[i - 1];
                }
                else {
                    left = Math.max(nums1[i - 1], nums2[j - 1]);
                }
                if ((m + n) % 2 == 1) {
                    return left * 1.0;
                }
                
                int right = 0;
                if (i == m) {
                    right = nums2[j];
                }
                else if (j == n) {
                    right = nums1[i];
                }
                else {
                    right = Math.min(nums1[i], nums2[j]);
                }
                return (left + right) / 2.0;
            }
        }
        return -1;
    }
}

死记住

45
Jump Game II (Done)

public class Solution {
    public int jump(int[] nums) {
        if (nums == null || nums.length <= 1) {
            return 0;
        }
        
        int step = 0;
        int edge = 0;
        int maxReach = nums[0];
        
        for (int i = 1; i < nums.length; i++) {
            if (i > edge) {
                edge = maxReach;
                step++;
                if (edge >= nums.length - 1) {
                    return step;
                }
            }
            maxReach = Math.max(maxReach, nums[i] + i);
        }
        
        return step;
    }
}

63, 在矩形四边处，处理上有点小问题 (Done)
Unique Paths II
public class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int[][] nums = obstacleGrid;
if (nums == null || nums.length == 0 || nums[0].length == 0) {
return 0;
}

    int row = nums.length;
    int col = nums[0].length;
    int temp = nums[0][0];
    int i = 0;
    for (; i < col; i++) {
        if (nums[0][i] == 0) {
            nums[0][i] = 1;
        }
        else {
            break;
        }
    }
    for (; i < col; i++) {
        nums[0][i] = 0;
    }
    
    nums[0][0] = temp;
    i = 0;
    for (; i < row; i++) {
        if (nums[i][0] == 0) {
            nums[i][0] = 1;
        }
        else {
            break;
        }
    }
    for (; i < row; i++) {
        nums[i][0] = 0;
    }
    
    for (i = 1; i < row; i++) {
        for (int j = 1; j < col; j++) {
            if (nums[i][j] == 1) {
                nums[i][j] = 0;
            }
            else {
                nums[i][j] = nums[i - 1][j] + nums[i][j - 1];
            }
        }
    }
    
    return nums[row - 1][col - 1];
}

}

31,
Next Permutation (Done)
有点不顺 注意，我们需要找的一定是 > nums[i] 的最小数
** 注意：nums[] 可能会有重复。所以一开始找区域时，是 >= 时，i--
然后找最接近的最大值时，不能特殊考虑相等的情况 **
public class Solution {
public void nextPermutation(int[] nums) {
if (nums == null || nums.length == 0) {
return;
}

    int i = nums.length - 2;
    while (i >= 0 && nums[i] >= nums[i + 1]) {
        i--;
    }
    if (i < 0) {
        reverse(nums, 0, nums.length - 1);
        return;
    }
    
    int begin = i + 1;
    int end = nums.length - 1;
    while (begin <= end) {
        int mid = begin + (end - begin) / 2;
        if (nums[mid] > nums[i]) {
            begin = mid + 1;
        }
        else {
            end = mid - 1;
        }
    }
    
    int temp = nums[end];
    nums[end] = nums[i];
    nums[i] = temp;
    reverse(nums, i + 1, nums.length - 1);
}

private void reverse(int[] nums, int i, int j) {
    int begin = i;
    int end = j;
    while (begin < end) {
        int temp = nums[begin];
        nums[begin] = nums[end];
        nums[end] = temp;
        begin++;
        end--;
    }
}

}

277,
Find the Celebrity (Done)
没做出来
/* The knows API is defined in the parent class Relation.
boolean knows(int a, int b); */

public class Solution extends Relation {
public int findCelebrity(int n) {
if (n <= 0) {
return -1;
}

    int candidate = 0;
    for (int i = 1; i < n; i++) {
        if (knows(candidate, i)) {
            candidate = i;
        }
    }
    
    for (int i = 0; i < n; i++) {
        if (i == candidate) {
            continue;
        }
        else if (knows(i, candidate) && !knows(candidate, i)) {
            continue;
        }
        else {
            return -1;
        }
    }
    
    return candidate;
}

}

280
Wiggle Sort (Done)
public class Solution {
public void wiggleSort(int[] nums) {
if (nums == null || nums.length == 0) {
return;
}

    for (int i = 0; i + 1 < nums.length; i += 2) {
        if (nums[i + 1] < nums[i]) {
            swap(nums, i, i + 1);
        }
    }
    for (int i = 1; i + 1 < nums.length; i += 2) {
        if (nums[i] < nums[i + 1]) {
            swap(nums, i, i + 1);
        }
    }
}

private void swap(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

}

34
Search for a Range (Done)
public class Solution {
public int[] searchRange(int[] nums, int target) {
if (nums == null || nums.length == 0) {
return new int[]{-1, -1};
}

    int begin = 0;
    int end = nums.length - 1;
    int index = -1;
    while (begin <= end) {
        int mid = begin + (end - begin) / 2;
        if (nums[mid] < target) {
            begin = mid + 1;
        }
        else if (nums[mid] > target) {
            end = mid - 1;
        }
        else {
            index = mid;
            break;
        }
    }
    if (index == -1) {
        return new int[]{-1, -1};
    }
    
    begin = 0;
    end = index - 1;
    while (begin <= end) {
        int mid = begin + (end - begin) / 2;
        if (nums[mid] == target) {
            end = mid - 1;
        }
        else {
            begin = mid + 1;
        }
    }
    int left = end + 1;
    
    begin = index + 1;
    end = nums.length - 1;
    while (begin <= end) {
        int mid = begin + (end - begin) / 2;
        if (nums[mid] == target) {
            begin = mid + 1;
        }
        else {
            end = mid - 1;
        }
    }
    int right = begin - 1;
    
    return new int[]{left, right};
}

}

163
Missing Ranges (Not Done)
** 注意可能越界，所有的 nums[i] + 1 or - 1 都得将 nums[i] 先转换成long **

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public List findMissingRanges(int[] nums, int lower, int upper) {
        List ret = new ArrayList();
        long min = lower;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > min) {
                String s = getRange(min, (long) nums[i] - 1);
                ret.add(s);
            }
            min = (long) nums[i] + 1;
        }
        if (min <= upper) {
            String s = getRange(min, upper);
            ret.add(s);
        }
        
        return ret;
    }
    
    private String getRange(long begin, long end) {
        if (begin == end) {
            return "" + begin;
        }
        else {
            return begin + "->" + end;
        }
    }
}

229,
Majority Element II (Done)
注意顺序，先判断i1, i2 非空时的情况，再判断空情况

public class Solution {
    public List majorityElement(int[] nums) {
        List ret = new ArrayList();
        if (nums == null || nums.length == 0) {
            return ret;
        }
        
        Integer i1 = null;
        Integer i2 = null;
        int c1 = 0;
        int c2 = 0;
        for (int i = 0; i < nums.length; i++) {
            if (i1 != null && i1 == nums[i]) {
                c1++;
            }
            else if (i2 != null && i2 == nums[i]) {
                c2++;
            }
            else if (i1 == null) {
                i1 = new Integer(nums[i]);
                c1 = 1;
            }
            else if (i2 == null) {
                i2 = new Integer(nums[i]);
                c2 = 1;
            }
            else {
                c1--;
                if (c1 == 0) {
                    i1 = null;
                }
                c2--;
                if (c2 == 0) {
                    i2 = null;
                }
            }
        }
        
        c1 = 0;
        c2 = 0;
        for (int i = 0; i < nums.length; i++) {
            if (i1 != null && i1 == nums[i]) {
                c1++;
            }
            else if (i2 != null && i2 == nums[i]) {
                c2++;
            }
        }
        
        if (c1 > nums.length / 3) {
            ret.add(i1);
        }
        if (c2 > nums.length / 3) {
            ret.add(i2);
        }
        return ret;
    }
}

370,
Range Addition (Done)
没做出来

public class Solution {
    public int[] getModifiedArray(int length, int[][] updates) {
        int[] ret = new int[length];
        for (int i = 0; i < updates.length; i++) {
            int start = updates[i][0];
            int end = updates[i][1];
            int step = updates[i][2];
            ret[start] += step;
            if (end + 1 < length) {
                ret[end + 1] -= step;
            }
        }
        
        for (int i = 1; i < length; i++) {
            ret[i] += ret[i - 1];
        }
        
        return ret;
    }
}

209,
Minimum Size Subarray Sum (Done)
有点不顺畅

public class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        int begin = 0;
        int end = 0;
        int minLength = Integer.MAX_VALUE;
        int sum = 0;
        while (end < nums.length) {
            sum += nums[end];
            if (sum >= s) {
                minLength = Math.min(minLength, end - begin + 1);
                sum -= nums[begin];
                begin++;
                if (begin > end) {
                    end = begin;
                }
                else {
                    sum -= nums[end];
                }
            }
            else {
                end++;
            }
        }
        
        return minLength == Integer.MAX_VALUE ? 0 : minLength;
    }
}

396,
Rotate Function (Done)
没做出来

public class Solution {
    public int maxRotateFunction(int[] A) {
        if (A == null || A.length == 0) {
            return 0;
        }
        
        int iteration = 0;
        int base = 0;
        for (int i = 0; i < A.length; i++) {
            base += i * A[i];
            iteration += A[i];
        }
        
        int max = base;
        for (int i = 1; i < A.length; i++) {
            base -= iteration;
            base += A.length * A[i - 1];
            max = Math.max(max, base);
        }
        
        return max;
    }
}

407
Trapping Rain Water II (Done)
忘记了还需要用 priority queue

public class Solution {
    private class Node {
        int x;
        int y;
        int height;
        Node (int x, int y, int height) {
            this.x = x;
            this.y = y;
            this.height = height;
        }
    }
    int row = 0;
    int col = 0;
    public int trapRainWater(int[][] heightMap) {
        if (heightMap == null || heightMap.length == 0 || heightMap[0].length == 0) {
            return 0;
        }
        
        this.row = heightMap.length;
        this.col = heightMap[0].length;
        PriorityQueue pq = new PriorityQueue(10, new Comparator() {
            public int compare(Node n1, Node n2) {
                return n1.height - n2.height;
            }    
        });
        boolean[][] mark = new boolean[row][col];
        for (int i = 0; i < col; i++) {
            pq.offer(new Node(0, i, heightMap[0][i]));
            mark[0][i] = true;
            if (row - 1 > 0) {
                pq.offer(new Node(row - 1, i, heightMap[row - 1][i]));
                mark[row - 1][i] = true;
            }
        }
        
        for (int i = 0; i < row; i++) {
            pq.offer(new Node(i, 0, heightMap[i][0]));
            mark[i][0] = true;
            if (col - 1 > 0) {
                pq.offer(new Node(i, col - 1, heightMap[i][col - 1]));
                mark[i][col - 1] = true;
            }
        }
        
        int sum = 0;
        int[][] dir = new int[][]{{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
        while (!pq.isEmpty()) {
            Node curr = pq.poll();
            for (int i = 0; i < 4; i++) {
                int next_x = curr.x + dir[i][0];
                int next_y = curr.y + dir[i][1];
                if (check(next_x, next_y) && !mark[next_x][next_y]) {
                    sum += Math.max(0, curr.height - heightMap[next_x][next_y]);
                    mark[next_x][next_y] = true;
                    pq.offer(new Node(next_x, next_y, Math.max(curr.height, heightMap[next_x][next_y])));
                }
            }
        }
        
        return sum;
    }
    
    private boolean check(int i, int j) {
        if (i < 0 || i >= row || j < 0 || j >= col) {
            return false;
        }
        return true;
    }
}

317
Shortest Distance from All Buildings (Done)
没做出来，今天要再写一遍

public class Solution {
    private class Node {
        int x;
        int y;
        int step;
        Node (int x, int y, int step) {
            this.x = x;
            this.y = y;
            this.step = step;
        }
    }
    
    int row = 0;
    int col = 0;
    int[][] dir = new int[][]{{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
    public int shortestDistance(int[][] grid) {
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }
        row = grid.length;
        col = grid[0].length;
        int[][] dist = new int[row][col];
        List list = new ArrayList();
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (grid[i][j] == 1) {
                    list.add(new Node(i, j, 0));
                }
                grid[i][j] = -grid[i][j];
            }
        }
        
        for (int i = 0; i < list.size(); i++) {
            bfs(list.get(i), grid, dist, i);
        }
        
        int max = Integer.MAX_VALUE;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (grid[i][j] == list.size()) {
                    max = Math.min(max, dist[i][j]);
                }
            }
        }
        
        return max == Integer.MAX_VALUE ? -1 : max;
    }
    
    private void bfs(Node root, int[][] grid, int[][] dist, int k) {
        Queue q = new LinkedList();
        q.offer(root);
        while (!q.isEmpty()) {
            Node curr = q.poll();
            for (int i = 0; i < 4; i++) {
                int nei_x = curr.x + dir[i][0];
                int nei_y = curr.y + dir[i][1];
                if (check(nei_x, nei_y) && grid[nei_x][nei_y] == k) {
                    q.offer(new Node(nei_x, nei_y, curr.step + 1));
                    dist[nei_x][nei_y] += curr.step + 1;
                    grid[nei_x][nei_y] = k + 1;
                }
            }
        }
    }
    
    private boolean check(int i, int j) {
        if (i < 0 || i >= row || j < 0 || j >= col) {
            return false;
        }
        return true;
    }
}

301
Remove Invalid Parentheses (Done)
基本写了出来，有点磨蹭

public class Solution {
    public List removeInvalidParentheses(String s) {
        List ret = new ArrayList();
        helper(0, 0, s, new char[]{'(', ')'}, ret);
        return ret;
    }
    
    private void helper(int last_i, int last_j, String s, char[] pair, List ret) {
        int cnt = 0;
        for (int i = last_i; i < s.length(); i++) {
            char curr = s.charAt(i);
            if (curr == pair[0]) {
                cnt++;
            }
            else if (curr == pair[1]) {
                cnt--;
                if (cnt < 0) {
                    for (int j = last_j; j <= i; j++) {
                        if (s.charAt(j) == pair[1] && (j == last_j || s.charAt(j - 1) != pair[1])) {
                            helper(i, j, s.substring(0, j) + s.substring(j + 1), pair, ret);
                        }
                    }
                    return;
                }
            }
        }
        
        String r = new StringBuilder(s).reverse().toString();
        if (pair[0] == '(') {
            helper(0, 0, r, new char[]{')', '('}, ret);
        }
        else {
            ret.add(r);
        }
    }
}

323
Number of Connected Components in an Undirected Graph (Done)
没想出来，以为还是用入度解

public class Solution {
    Map> map = new HashMap>();
    int V;
    public int countComponents(int n, int[][] edges) {
        this.V = n;
        for (int i = 0; i < edges.length; i++) {
            int u = edges[i][0];
            int v = edges[i][1];
            if (!map.containsKey(u)) {
                map.put(u, new HashSet());
            }
            if (!map.containsKey(v)) {
                map.put(v, new HashSet());
            }
            map.get(u).add(v);
            map.get(v).add(u);
        }
        
        boolean[] mark = new boolean[n];
        int cnt = 0;
        for (int i = 0; i < n; i++) {
            if (!mark[i]) {
                cnt++;
                bfs(i, mark);
            }
        }
        
        return cnt;
    }
    
    private void bfs(int root, boolean[] mark) {
        mark[root] = true;
        Queue q = new LinkedList();
        q.offer(root);
        while (!q.isEmpty()) {
            int curr = q.poll();
            if (map.containsKey(curr)) {
                Set nei = map.get(curr);
                for (Integer temp : nei) {
                    if (!mark[temp]) {
                        mark[temp] = true;
                        q.offer(temp);
                    }
                }
            }
        }
    }
}

279
Perfect Squares (Done)
没做出来

public class Solution {
    public int numSquares(int n) {
        if (n <= 0) {
            return 0;
        }
        
        int[] dp = new int[n + 1];
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            int min = Integer.MAX_VALUE;
            int j = 1;
            while (j * j <= i) {
                min = Math.min(min, 1 + dp[i - j * j]);
                j++;
            }
            dp[i] = min;
        }
        
        return dp[n];
    }
}

261
Graph Valid Tree
没做出来

public class Solution {
    Map> map = new HashMap>();
    public boolean validTree(int n, int[][] edges) {
        for (int i = 0; i < edges.length; i++) {
            int u = edges[i][0];
            int v = edges[i][1];
            if (!map.containsKey(u)) {
                map.put(u, new HashSet());
            }
            if (!map.containsKey(v)) {
                map.put(v, new HashSet());
            }
            map.get(u).add(v);
            map.get(v).add(u);
        }
        
        int cnt = 0;
        boolean[] mark = new boolean[n];
        Queue q = new LinkedList();
        q.offer(0);
        mark[0] = true;
        while (!q.isEmpty()) {
            int curr = q.poll();
            cnt++;
            if (map.containsKey(curr)) {
                Set nei = map.get(curr);
                for (Integer temp : nei) {
                    if (mark[temp]) {
                        return false;
                    }
                    mark[temp] = true;
                    map.get(temp).remove(curr);
                    q.offer(temp);
                }
            }
        }
        
        return cnt == n;
    }
}

269
Alien Dictionary (Not finished)
test case 更新了，没写对
** 记住！图中，利用入度解决问题时，一定要判断，
if (!map.get(u).contains(v)) {// 再去更新入度}
删去入度时，也得先判断，当前的 u， 是否存在于 map 中 **

public class Solution {
    Map> map = new HashMap>();
    Map indegree = new HashMap();
    public String alienOrder(String[] words) {
        if (words == null || words.length == 0) {
            return "";
        }
        for (String word : words) {
            for (char c : word.toCharArray()) {
                indegree.put(c, 0);
            }
        }
        
        for (int i = 0; i < words.length - 1; i++) {
            String s1 = words[i];
            String s2 = words[i + 1];
            int k = 0;
            while (k < Math.min(s1.length(), s2.length())) {
                if (s1.charAt(k) == s2.charAt(k)) {
                    k++;
                }
                else {
                    break;
                }
            }
            if (k == Math.min(s1.length(), s2.length())) {
                if (s1.length() > s2.length()) {
                    return "";
                }
                else {
                    continue;
                }
            }
            else {
                char c1 = s1.charAt(k);
                char c2 = s2.charAt(k);
                if (!map.containsKey(c1)) {
                    map.put(c1, new HashSet());
                }
                if (!map.get(c1).contains(c2)) {
                    map.get(c1).add(c2);
                    indegree.put(c2, indegree.get(c2) + 1);
                }
            }
        }
        
        Queue q = new LinkedList();
        for (Character c : indegree.keySet()) {
            if (indegree.get(c) == 0) {
                q.offer(c);
            }
        }
        
        String ret = "";
        while (!q.isEmpty()) {
            char c = q.poll();
            ret += c;
            if (map.containsKey(c)) {
                Set nei = map.get(c);
                for (Character temp : nei) {
                    indegree.put(temp, indegree.get(temp) - 1);
                    if (indegree.get(temp) == 0) {
                        q.offer(temp);
                    }
                }
            }
        }
        
        if (ret.length() == indegree.size()) {
            return ret;
        }
        else {
            return "";
        }
    }
}

332
Reconstruct Itinerary (Done)
基本写对了，还有小Bug

public class Solution {
    public List findItinerary(String[][] tickets) {
        List ret = new ArrayList();
        Map> map = new HashMap>();
        for (int i = 0; i < tickets.length; i++) {
            String src = tickets[i][0];
            String dest = tickets[i][1];
            if (!map.containsKey(src)) {
                map.put(src, new ArrayList());
            }
            insert(dest, map.get(src));
        }
        
        ret.add("JFK");
        int total = tickets.length;
        helper("JFK", total, map, ret);
        return ret;
    }
    
    private boolean helper(String src, int total, Map> map, List ret) {
        if (total == 0) {
            return true;
        }
        else {
            List dests = map.get(src);
            if (dests == null || dests.size() == 0) {
                return false;
            }
            for (int i = 0; i < dests.size(); i++) {
                String dest = dests.get(i);
                ret.add(dest);
                dests.remove(i);
                boolean flag = helper(dest, total - 1, map, ret);
                if (flag) {
                    return true;
                }
                ret.remove(ret.size() - 1);
                dests.add(i, dest);
            }
            return false;
        }
    }
    
    private void insert(String s, List list) {
        int i = 0;
        for (; i < list.size(); i++) {
            if (s.compareTo(list.get(i)) <= 0) {
                break;
            }
        }
        if (i >= list.size()) {
            list.add(s);
        }
        else {
            list.add(i, s);
        }
    }
}

99
Recover Binary Search Tree (Done)
没做出来

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void recoverTree(TreeNode root) {
        if (root == null) {
            return;
        }
        
        TreeNode small = null;
        TreeNode big = null;
        Stack st = new Stack();
        TreeNode p = root;
        while (p != null) {
            st.push(p);
            p = p.left;
        }
        TreeNode pre = null;
        int cnt = 0;
        while (!st.isEmpty()) {
            TreeNode curr = st.pop();
            if (pre == null || pre.val < curr.val) {
                pre = curr;
            }
            else {
                if (cnt == 0) {
                    big = pre;
                    small = curr;
                    cnt++;
                }
                else {
                    small = curr;
                }
            }
            
            if (curr.right != null) {
                curr = curr.right;
                while (curr != null) {
                    st.push(curr);
                    curr = curr.left;
                }
            }
        }
        
        int temp = big.val;
        big.val = small.val;
        small.val = temp;
    }
}

394
Decode String (Not finished)
没做出来，和 basic calculator很像

public class Solution {
    public String decodeString(String s) {
        if (s == null || s.length() == 0) {
            return s;
        }
        
        Stack st = new Stack();
        Stack cnt = new Stack();
        int num = 0;
        String result = "";
        for (int i = 0; i < s.length(); i++) {
            char curr = s.charAt(i);
            if (Character.isDigit(curr)) {
                num = 10 * num + (curr - '0');
            }
            else if (curr == '[') {
                st.push(result);
                cnt.push(num);
                result = "";
                num = 0;
            }
            else if (curr == ']') {
                int counter = cnt.pop();
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < counter; j++) {
                    sb.append(result);
                }
                result = st.pop() + sb.toString();
            }
            else {
                result += curr;
            }
        }
        
        return result;
    }
}

227
Basic Calculator II
没做出来,因为有乘除，得有一个 char 来保存前一个运算符

224
Basic Calculator
没做出来

  1. Find Leaves of Binary Tree
    没能拿最优解来做

  2. Nested List Weight Sum II
    没做出来

  3. House Robber III
    没做出来

  4. Interleaving String
    没做出来

  5. Word Break II
    有点生疏，一开始忘记加cache了

  6. Distinct Subsequences
    没做出来

188.Best Time to Buy and Sell Stock IV
没做出来

  1. Scramble String
    基本思路有了，有几个东西忘了
    1 . isSame, 用老判断字母组成是否一致
    2 . cache, 三维dp,
    dp[len][len][len + 1]

  2. Palindrome Partitioning II
    没做出来

  3. Create Maximum Number
    没做出来

  4. Remove K Digits
    自己写了出来，但有些corner case 没考虑到
    比如，最后的结果，可能有leading zero, 要去了
    比如， 最后的结果，可能长度为0，这个时候不能返回空字符串，得返回 “0”

  5. Max Sum of Rectangle No Larger Than K
    getMaxWithK()
    写的有些问题
    set.add(0)
    还有temp, 要在判断之后再加入set中

Paint House II
没做出来,
min1, min2
lastMin1, lastMin2

  1. Ugly Number II
    总是记不住！
    int[] dp
    i2, i3, i5 三个指针指向dp

  1. Coin Change
    写的不顺畅
    而且， 内循环，循环的是 coins array

  2. Maximal Square
    递推式写的不对。
    记住，是左，上，左上，三个点

  3. Counting Bits
    没做出来

  4. Best Time to Buy and Sell Stock with Cooldown
    没做出来

  5. Combination Sum IV
    没做出来，和 coin change 很类似,只不过 coin change 求的是最小值，这里是累加

  6. Guess Number Higher or Lower II
    没做出来，和 burst baloon 很像

  7. Android Unlock Patterns
    没做出来。
    skip[][] 是关键

  8. Largest Divisible Subset
    先找出最长子链的长度，以及index，然后再倒退后去复原

  9. Is Subsequence
    原题不难。
    但是对于follow up, 需要构造map,然后用 binary search 来做

  10. Bomb Enemy
    没做出来
    updateRow
    updateCol

  11. Paint Fence
    没做出来。
    分成两种类型
    diff,
    same

  12. Longest Substring with At Most Two Distinct Characters
    没做来，这么重要的题目。
    不应该。
    leftMost

Longest Substring Without Repeating Characters
自己写了出来，但有点磨蹭

  1. Longest Substring with At Most K Distinct Characters
    本可以做出来的，犯了低级错误。
    map.remove 是移除 character

  2. Read N Characters Given Read4
    忘记怎么做了

  3. Read N Characters Given Read4 II - Call multiple times
    知道简单版怎么做后，这个也很容易做了，加一个全局变量队列就行

  4. Palindrome Pairs
    自己写了出来。
    但是错了挺多次。
    处理好：
    isPalindrome
    reverse = s, “” contains in map
    if word == “”, continue

  5. Shortest Palindrome
    基本思路记得，但写的还是不顺手，没写出来

  6. Valid Number
    没能最后写出来。
    dot, if (dot || exp)
    exp, if (!num || exp)
    还有 curr == ‘+’ or ‘-‘ after exp

  7. Substring with Concatenation of All Words
    和 minimum window substring 很类似，只不过一个是 string, 一个是 character
    这里要注意的是，
    有两个map
    外层for循环，i < len

  8. Mini Parser
    没做出来，和 basic calculator很像。
    关键一步在于，一开始判断[0] 是否为 ‘[‘

  1. Encode and Decode Strings
    没做出来
    length of string + “/“ + string

  2. Group Anagrams
    hashcode 没想到怎么求，
    原来直接有系统函数：
    Arrays.hashCode(char[] arr)

  3. Group Shifted Strings
    基本思路是正确的。注意偏差offset

  4. Flip Game II
    忘记怎么做了

  5. Generalized Abbreviation
    没做出来。其实思路和
    interleave string 很像

  6. Valid Word Abbreviation
    没做出来，看的答案

  7. Frog Jump
    没做出来
    DP， 看的答案

  8. Sudoku Solver
    基本写了出来。
    记住， for 循环结束后，
    board[i][j] = ‘.’;
    return false;

  9. Meeting Rooms II
    有点疙瘩

  10. Min Stack
    粗心错了，还得再写一遍

  11. Sliding Window Maximum
    Deque
    peekFirst(), 左侧
    peekLast(), 右侧
    队列内部保持一个递减数列，
    所以第一个循环，
    q.peekFirst()
    第二个循环，
    q.peekLast()

  12. Maximum Size Subarray Sum Equals k
    没做出来。
    注意三种题：
    minimum size subaray sum <= k, all members are positive
    => sliding window
    maximum size subarray sum equals k
    => sums[], and using two sum
    maximum size subarray sum <= k
    => need to use TreeMap

你可能感兴趣的:(Leetcode - 刷题总结3)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • 《策划经理回忆录之二》 路基雅虎
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • swagger访问路径 igotyback swagger
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
  • 30天风格练习-DAY2 黄希夷
    Day2（重义）在一个周日/一周的最后一天，我来到位于市中心/市区繁华地带的一家购物中心/商场，中心内人很多/熙熙攘攘。我注意到/看见一个独行/孤身一人的年轻女孩/，留着一头引人注目/长过腰际的头发，上身穿一件暗红色/比正红色更深的衣服/穿在身体上的东西。走下扶梯的时候，她摔倒了/跌向地面，在她正要站起来/让身体离开地面的时候，过长/超过一般人长度的头发被支撑身体/躯干的手掌压/按在下面，她赶紧用
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 开心 蒋泳频
    从无比抗拒来上课到接受，感动，收获～看着波哥成长，晶晶幸福笑容满面。感觉自己做的事情很有意义，很开心！还有3个感召目标就是还有三个有缘人，哈哈。明天感召去明日计划：8：30-11：00小公益11：00-21点上班，感召图片发自App图片发自App图片发自App
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿 小鹿_33
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
  • 本周第二次约练 2cfbdfe28a51
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • 今日联对0306 诗图佳得
    自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.1、试对肖老师联：烟销皓月临江浒，夜笼寒沙梦晚舟。耀哥求正2、试对萧老师联:烟销浩月临江浒，雾散乾坤解汉城。秀霞习作请各位老师校正3、自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.4、试对肖老师垫场联：烟销皓月临江浒，雾锁寒林缈葉丛。小智求正[抱拳]5、试对肖老师联：烟销皓月临江浒；风卷乱云入峰巅。一一五品6
  • 每日一题——第八十九题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • 《小满细雨轻湿尘》 快乐的人ZZM
    图片发自App《小满细雨轻湿尘》文/快乐的人zzm小满细雨轻湿尘石榴花开落纷纷落红不是无情物坠入泥土育养根2018-5-23
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • 怎么起诉借钱不还的人？怎样起诉欠款不还的人？ 影子爱学习
    怎么起诉借钱不还的人？怎样起诉欠款不还的人？如果遇到难以解决的法律问题，我们可以匹配专业律师。例如：婚姻家庭（离婚纠纷）、刑事辩护、合同纠纷、债权债务、房产（继承）纠纷、交通事故、劳动争议、人身损害、公司相关法律事务（法律顾问）等咨询推荐手机/微信:15633770876【全国案件皆可】借钱不还起诉对方需要哪些资料起诉欠钱不还的，一般需要的材料包括以下这些：借据、收据、欠条、付款凭证等证据，以及向
  • 2019-12-22-22:30 涓涓1016
    今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
  • linux sdl windows.h,Windows下的SDL安装 奔跑吧linux内核 linuxsdlwindows.h
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • 相信相信的力量 孙丽_cdb3
    孙丽中级十期坚持分享第345天有一个特别有哲理的故事：有一只老鹰下了蛋，这个蛋，不知怎的就滚到了鸡窝里去了，鸡也下了一窝蛋，然后鸡妈妈把这些蛋全都浮出来了，孵出来之后等小鸡长大一点了，就觉得鹰蛋孵出来的那只小鹰怪模怪样，这些小鸡都嘲笑它，真难看，真笨，丑死了，那只小鹰觉得自己真是谁也不像，真是不好看，后来鸡妈妈也不喜欢他，我怎么生出你这样的孩子来了？真烦人，后来这群小鸡和小鹰一起生活，有一天，老鹰
  • 感赏日志133 马姐读书
    图片发自App感赏自己今天买个扫地机，以后可以解放出来多看点书，让这个智能小机器人替我工作了。感赏孩子最近进步很大，每天按时上学，认真听课，认真背书，主动认真完成老师布置的作业。感赏自己明白自己容易受到某人的影响，心情不好，每当此刻我就会舒缓，感赏，让自己尽快抽离，想好的一面。感赏儿子今天在我提醒他事情时，告诉我谢谢妈妈对我的提醒我明白了，而不是说我啰嗦，管事情，孩子更懂事了，懂得感恩了。投射父母
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 二分查找排序算法 周凡杨 java二分查找排序算法折半
    一：概念 二分查找又称 折半查找（ 折半搜索/ 二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而 查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表 分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
  • java中的BigDecimal bijian1013 javaBigDecimal
            在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。         原文地址：http://blog.csdn.net/ugg/article/de
  • Shell echo命令详解 daizj echoshell
    Shell echo命令 Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： echo string 您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: echo "It is a test" 这里的双引号完全可以省略，以下命令与上面实例效果一致： echo Itis a test 2.显示转义
  • Oracle DBA 简单操作 周凡杨 oracle dba sql
    --执行次数多的SQL select sql_text,executions from (      select sql_text,executions from v$sqlarea order by executions desc      ) where rownum<81;  &nb
  • 画图重绘 朱辉辉33 游戏
      我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。   在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
  • 线程之初体验 西蜀石兰 线程
    一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。 之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。 线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。 你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
  • linux集群互相免登陆配置 林鹤霄 linux
    配置ssh免登陆 1、生成秘钥和公钥    ssh-keygen -t rsa 2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub    其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密    c
  • mysql : Lock wait timeout exceeded; try restarting transaction aigo mysql
    原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html   原因是你使用的InnoDB   表类型的时候, 默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 因为有的锁等待超过了这个时间,所以抱错.   你可以把这个时间加长,或者优化存储
  • Socket编程 基本的聊天实现。 alleni123 socket
    public class Server { //用来存储所有连接上来的客户 private List<ServerThread> clients; public static void main(String[] args) { Server s = new Server(); s.startServer(9988); } publi
  • 多线程监听器事件模式(一个简单的例子) 百合不是茶 线程监听模式
        多线程的事件监听器模式   监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到        创建多线程的事件监听器模式 思路:    1, 创建线程并启动,在创建线程的位置设置一个标记     2,创建队
  • spring InitializingBean接口 bijian1013 javaspring
    spring的事务的TransactionTemplate，其源码如下： public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{ ... } TransactionTemplate继承了DefaultT
  • Oracle中询表的权限被授予给了哪些用户 bijian1013 oracle数据库权限
            Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 select t.table_name as "表名", t.grantee as "被授权的属组", t.owner as "对象所在的属组"
  • 【Struts2五】Struts2 参数传值 bit1129 struts2
    Struts2中参数传值的3种情况 1.请求参数绑定到Action的实例字段上 2.Action将值传递到转发的视图上 3.Action将值传递到重定向的视图上   一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上 Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
  • 【Kafka十四】关于auto.offset.reset[Q/A] bit1129 kafka
    I got serveral questions about  auto.offset.reset. This configuration parameter governs how  consumer read the message from  Kafka when  there is no initial offset in ZooKeeper or
  • nginx gzip压缩配置 ronin47 nginx gzip 压缩范例
    nginx gzip压缩配置 更多 0 nginx gzip 配置   随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
  • java-13.输入一个单向链表，输出该链表中倒数第 k 个节点 bylijinnan java
    two cursors. Make the first cursor go K steps first. /* * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点 */ public void displayKthItemsBackWard(ListNode head,int k){ ListNode p1=head,p2=head;
  • Spring源码学习-JdbcTemplate queryForObject bylijinnan javaspring
    JdbcTemplate中有两个可能会混淆的queryForObject方法： 1. Object queryForObject(String sql, Object[] args, Class requiredType) 2. Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 第1个方法是只查
  • [冰川时代]在冰川时代,我们需要什么样的技术? comsci 技术
         看美国那边的气候情况....我有个感觉...是不是要进入小冰期了?      那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段...   &nb
  • js 获取浏览器型号 cuityang js浏览器
    根据浏览器获取iphone和apk的下载地址 <!DOCTYPE html> <html> <head>     <meta charset="utf-8" content="text/html"/>     <meta name=
  • C# socks5详解 转 dalan_123 socketC#
    http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html  这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
  • 运维 Centos问题汇总 dcj3sjt126com 云主机
    一、sh 脚本不执行的原因 sh脚本不执行的原因 只有2个 1.权限不够 2.sh脚本里路径没写完整。   二、解决You have new mail in /var/spool/mail/root 修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 MailTo = MailFrom   三、查询连接数
  • Yii防注入攻击笔记 dcj3sjt126com sqlWEB安全yii
    网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号 这里有个转义对照表： http://blog.csdn.net/xinzhu1990/articl
  • MongoDB简介[一] eksliang mongodbMongoDB简介
    MongoDB简介 转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用        MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。        另外，不
  • zookeeper windows 入门安装和测试 greemranqq zookeeper安装分布式
    一、序言       以下是我对zookeeper 的一些理解：      zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。       栗子1号：       假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
  • Spring之使用事务缘由(2-注解实现) ihuning spring
      Spring事务注解实现   1. 依赖包：     1.1 spring包：           spring-beans-4.0.0.RELEASE.jar           spring-context-4.0.0.
  • iOS App Launch Option 啸笑天 option
    iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。   launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节 。 1、若用户直接
  • jdk与jre的区别（_） macroli javajvmjdk
    简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。  JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。 如果安装了JDK，会发同你
  • Updates were rejected because the tip of your current branch is behind qiaolevip 学习永无止境每天进步一点点众观千象git
    $ git push joe prod-2295-1 To [email protected]:joe.le/dr-frontend.git ! [rejected] prod-2295-1 -> prod-2295-1 (non-fast-forward) error: failed to push some refs to '[email protected]
  • [一起学Hive]之十四-Hive的元数据表结构详解 superlxw1234 hivehive元数据结构
    关键字：Hive元数据、Hive元数据表结构   之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。 本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。   文章最后面，会以一个示例来全面了解一下，
  • Spring 3.2.14，4.1.7，4.2.RC2发布 wiselyman Spring 3
      Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。   其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。   其中Spring 4.1.7主要包含这些更新内容。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他