CleanCodeHandbook Chapter 6: Misc(35-38)

Misc

leetcode54. Spiral Matrix

题目链接
题目：给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

思路：根据题目意思，可以得到下图，然后每次走完一行或者一列就用两个变量来记录，直到走完矩阵所有点，返回列表。

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> ans = new ArrayList<>();
        if(matrix.length == 0){
            return ans;
        }
        //行row
        int row = matrix.length;
        //列col
        int col = matrix[0].length;
        //起始位置 初始化
        int x = 0, y = -1;
        while(true){
            //从左向右走
            for(int i = 0; i < col; i++){
                ans.add(matrix[x][++y]);
            }
            //从左向右走完一行，总行数减一
            if(--row <= 0){
                break;
            }
            //从上向下走
            for(int i = 0; i < row; i++){
                ans.add(matrix[++x][y]);
            }
            //从上向下走完一列，总列数减一
            if(--col <= 0){
                break;
            }
            //从右向左走
            for(int i = 0; i < col; i++){
                ans.add(matrix[x][--y]);
            }
            //从右向左走完一行，总行数减一
            if(--row <= 0){
                break;
            }
            //从下向上走
            for(int i = 0; i < row; i++){
                ans.add(matrix[--x][y]);
            }
            //从下向上走完一列，总列数减一
            if(--col <= 0){
                break;
            }         
        }
        return ans;
    }
}

leetcode12. Spiral Matrix

题目链接
题目：罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。

字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个整数，将其转为罗马数字。输入确保在 1 到 3999 的范围内。

示例 1:

输入: 3
输出: “III”
示例 2:

输入: 4
输出: “IV”
示例 3:

输入: 9
输出: “IX”
示例 4:

输入: 58
输出: “LVIII”
解释: L = 50, V = 5, III = 3.
示例 5:

输入: 1994
输出: “MCMXCIV”
解释: M = 1000, CM = 900, XC = 90, IV = 4.

题目思路：把各个罗马数字和数值一一对应起来，把整数从最大的罗马整数开始减，直到减为0.

class Solution {
    public String intToRoman(int num) {
        String ans = "";
        int[] nums = {1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000};
        String[] romans = {"I", "IV", "V","IX","X","XL","L","XC","C","CD","D","CM","M"};
        for(int i = 12; i >= 0; i--){
            while(num >= nums[i]){
                num -= nums[i];
                ans += romans[i];
            }
        }
        return ans;
    }
}

leetcode13. Roman to Integer

题目链接
题目描述：罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

示例 1:

输入: “III”
输出: 3
示例 2:

输入: “IV”
输出: 4
示例 3:

输入: “IX”
输出: 9
示例 4:

输入: “LVIII”
输出: 58
解释: L = 50, V= 5, III = 3.
示例 5:

输入: “MCMXCIV”
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.

题目思路：遍历字符串，找到其对应的数值，需要注意一下 如果是"I"、“X”、"C"等，按理说罗马数字都是按照其对应的数值从大到小排列，如果出现后面比前面的数值大，这个时候，则说明是个组合 比如 IV 代表4，“I”对应1 “V”对应5,5比1大，因为当前面遇到“I”的时候已经把它加了一次，所以遇到其后面的“V”，需要讲其值减掉2倍的前一个数值。

class Solution {
   private Map<Character, Integer> map = new HashMap<Character, Integer>() {{
                put('I', 1); put('V', 5); put('X', 10);
                put('L', 50); put('C', 100); put('D', 500);
                put('M', 1000);
            }};
    public int romanToInt(String s){
        int pre = 0, curr;
        int sum = 0;
        for(char ch : s.toCharArray()){
            curr = map.get(ch);
            sum += (curr > pre) ? curr - 2 * pre : curr; 
            pre = curr;
        }
        return sum;
    }
}

leetcode133. Clone Graph

题目链接
题目描述：给定无向连通图中一个节点的引用，返回该图的深拷贝（克隆）。图中的每个节点都包含它的值 val（Int） 和其邻居的列表（list[Node]）。

示例：

输入：
{“KaTeX parse error: Expected '}', got 'EOF' at end of input: …"neighbors":[{"id”:“2”,“neighbors”:[{“KaTeX parse error: Expected 'EOF', got '}' at position 9: ref":"1"}̲,{"id”:“3”,“neighbors”:[{“KaTeX parse error: Expected 'EOF', got '}' at position 9: ref":"2"}̲,{"id”:“4”,“neighbors”:[{“KaTeX parse error: Expected 'EOF', got '}' at position 9: ref":"3"}̲,{"ref”:“1”}],“val”:4}],“val”:3}],“val”:2},{"$ref":“4”}],“val”:1}

解释：
节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
节点 4 的值是 4，它有两个邻居：节点 1 和 3 。

提示：

节点数介于 1 到 100 之间。
无向图是一个简单图，这意味着图中没有重复的边，也没有自环。
由于图是无向的，如果节点 p 是节点 q 的邻居，那么节点 q 也必须是节点 p 的邻居。
必须将给定节点的拷贝作为对克隆图的引用返回
参考

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> neighbors;

    public Node() {}

    public Node(int _val,List<Node> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
};
*/
class Solution {
    public Node cloneGraph(Node node) {
        HashMap<Node, Node> map =new HashMap<Node,Node>();
        Node clone = new Node(node.val,new LinkedList<Node>());
        map.put(node,clone);
        cloneGraphHelper(node, map);
        return clone;
    }
    public void cloneGraphHelper(Node node, HashMap<Node,Node> map){
        for (Node neighbor: node.neighbors) {
            if(!map.containsKey(neighbor)){
                Node newNeighbor = new Node(neighbor.val, new LinkedList<Node>());
                map.put(neighbor, newNeighbor);
                cloneGraphHelper(neighbor, map);
            }
            map.get(node).neighbors.add(map.get(neighbor));
        }
    }
}