leetcode387-441简单题

383. 赎金信

题目：
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。)

思路：
用一个长度26的vector保存出现的字母的次数，再将其减去ransomNote中出现的相同的字母的次数，如果数值小于0就返回false。

代码：

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] bucket = new int[26];
        for (int i=0;i<magazine.length();i++){
            bucket[magazine.charAt(i) - 'a']++;
        }
        for(int i=0;i<ransomNote.length();i++){
            if(--bucket[ransomNote.charAt(i) - 'a'] < 0)
                return false;
        }
        return true;
    }
}

public:
    bool canConstruct(string ransomNote, string magazine) {
        vector<int> vec(26,0);
        for(int i=0;i<magazine.size();i++)
            vec[magazine[i]-'a']++;
        for(int i=0;i<ransomNote.size();i++){
            vec[ransomNote[i]-'a']--;
            if(vec[ransomNote[i]-'a']<0)
                return false;
        }
        return  true;
    }
};

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int hash[26] = {0};
        for(int i=0;i<magazine.size();i++)
            hash[magazine[i]-'a']++;
        for(int i=0;i<ransomNote.size();i++){
            hash[ransomNote[i]-'a']--;
            if(hash[ransomNote[i]-'a']<0)
                return false;
        }
        return  true;
    }
};

387 字符串中的第一个唯一字符

题目：
给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1

代码：

public:
    int firstUniqChar(string s) {
        int count[26]={0};
        for(int i=0;i<s.size();i++){
            count[s[i]-'a']++;
        }
        for(int i=0;i<s.length();i++){
            if(count[s[i]-'a']==1)
                return i;
        }
        return -1;
    }
};

class Solution {
    public int firstUniqChar(String s) {
        int count[] = new int[26];
        //for(int i=0;i<s.length();i++){
        //    count[s.charAt(i)-'a']++;
        //}  //速度慢
        for(char c:s.toCharArray()){
            count[c-'a']++;
        }
        for(int i = 0;i<s.length();i++){
            if(count[s.charAt(i)-'a']-1==0)
                return i;
        }
        return -1;
    }
}

389 找不同

题目：
给定两个字符串 s 和 t，它们只包含小写字母。

字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。

请找出在 t 中被添加的字母。

代码：

class Solution {
public:
    char findTheDifference(string s, string t) {
        unordered_map<char, int> hash;
        
        for (int i:s) 
        {
            if (hash.find(i) != hash.end()) hash[i]++;
            else hash[i] = 1;
        }
        
        for (int i:t) {
            if (hash.find(i) != hash.end()) {
                hash[i]--;
                if (hash[i] == 0) hash.erase(i);
            }    
            else return i;
        }  
        return 0;
        
    }
};

class Solution {
    public char findTheDifference(String s, String t) {
        char[] sc = s.toCharArray();
        char[] tc = t.toCharArray();
        
        int count = 0;
        for(int i=0;i<sc.length;i++){
            count += tc[i] - sc[i];
        }
        count += tc[tc.length-1] -'a';
        return (char)(count+'a');
    }
}

392 判断子序列

题目：
给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长（长度 ~= 500,000），而 s 是个短字符串（长度 <=100）。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

代码：

class Solution {
public:
    bool isSubsequence(string s, string t) {
        if(s.size()==0)
            return true;
        int len = s.size();
        int a=0;
        for(int i=0;i<t.size();i++){
            if(s[a]==t[i])
                a++;
            if(a==len)
                return true;
        }
        return false;
    }
};

404 左子树之和

题目： 计算给定二叉树的所有左叶子之和。

思想： 利用递归的思想循环所有的叶子节点，flag标识是否为左子树；如果是左子树，判断其子节点是否为空；如果为空就计算其sum。遍历完后就可以得到最后的sum。

代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int sum = 0;
    public int sumOfLeftLeaves(TreeNode root) {
        boolean  flag = false;
        return inorder(root,flag);
    }
    
    public int inorder(TreeNode root,boolean flag){
        if (root == null)
            return 0;
        inorder(root.left,true);
        if(root.left == null && root.right == null && flag == true)
            sum += root.val;
        inorder(root.right,false);
        return sum;
    } 
}

405 数字转换为十六进制数

题目：
给定一个整数，编写一个算法将这个数转换为十六进制数。对于负整数，我们通常使用 补码运算 方法。

注意:
十六进制中所有字母(a-f)都必须是小写。
十六进制字符串中不能包含多余的前导零。如果要转化的数为0，那么以单个字符’0’来表示；对于其他情况，十六进制字符串中的第一个字符将不会是0字符。
给定的数确保在32位有符号整数范围内。
不能使用任何由库提供的将数字直接转换或格式化为十六进制的方法。

代码：

class Solution:
    def toHex(self, num: int) -> str:
        num &= 0xFFFFFFFF
        s = "0123456789abcdef"
        res = ""
        mask = 0b1111
        while num > 0:
            res += s[num & mask]
            num >>= 4
        return res[::-1] if res else "0"

415 Add String

题目：
给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。
注意：
num1 和num2 的长度都小于 5100.
num1 和num2 都只包含数字 0-9.
num1 和num2 都不包含任何前导零。
你不能使用任何內建 BigInteger 库， 也不能直接将输入的字符串转换为整数形式。
思路：
利用while循环对两个string的每个index位置的值相加，相加时注意判断进位值是0还是1，在下一次的index位置的字符相加的时候需要加上进位的值；每个index位置的值通过s.chaAt() - '0’将字符转换成int类型进行相加，加完后拼接到result中。

建议用StringBuilder附加结果，速度能快很多；顺序附加最后再翻转字符串。

代码：

class Solution {
    public String addStrings(String num1, String num2) {
        int num1Len = num1.length()-1;
        int num2Len = num2.length()-1;
        int flag = 0;
        String result = "";
        while(num1Len>=0||num2Len>=0){
            int temp1,temp2;
            if(num1Len>=0){
                temp1 = num1.charAt(num1Len--) - '0';
            }else{
                temp1 = 0;
            }
            if(num2Len>=0){
                temp2 = num2.charAt(num2Len--) - '0';
            }else{
                temp2 = 0;
            }
            int tempSum = temp1 + temp2;
            result = (char)((tempSum%10 + flag)%10 + '0') + result;
            flag = (tempSum + flag)/10;
            
        }
        if(flag==1) result = flag + result;
        return result;
    }
}

434 字符串中的单词数

题目：
统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。

请注意，你可以假定字符串里不包括任何不可打印的字符。
示例:
输入: “Hello, my name is John”
输出: 5
解释: 这里的单词是指连续的不是空格的字符，所以 “Hello,” 算作 1 个单词。

思路：
遍历一遍判断一下前后两位的空格。

代码：

class Solution {
    public int countSegments(String s) {
        int count = 0;
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)!=' '&&(i==0||s.charAt(i-1)==' '))
                count++;
        }
        return count;
    }
}

437. 路径总和 III

题目：
给定一个二叉树，它的每个结点都存放着一个整数值。

找出路径和等于给定数值的路径总数。

路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。

思路：
此题是典型的DFS题，注意递归的条件就行。

代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    int count = 0;
    public int pathSum(TreeNode root, int sum) {
        if(root==null) return 0;
        
        DFS(root,sum);
        pathSum(root.left,sum);
        pathSum(root.right,sum);
        return count;
    }
    public void DFS(TreeNode node,int sum){
        if(node==null) return;
        
        if(sum == node.val) count++;
        DFS(node.left,sum-node.val);
        DFS(node.right,sum-node.val);
    }
}

class Solution {
    public int pathSum(TreeNode root, int sum) {
        int count = 0;
        Stack<TreeNode> sk = new Stack();
        while(!sk.empty()||root!=null){
            if(root!=null){
                sk.push(root);
                root = root.left;
            }else{
                root = sk.pop();
                count += DFS(root,sum);
                root = root.right;
            }
        }
        return count;
    }
    public int DFS(TreeNode node,int sum){
        if(node==null) return 0;
        
        int num = 0;
        if(sum-node.val==0) num=1;
        return DFS(node.left,sum-node.val)+DFS(node.right,sum-node.val)+num;
    }
}

441. 排列硬币

题目：
你总共有 n 枚硬币，你需要将它们摆成一个阶梯形状，第 k 行就必须正好有 k 枚硬币。

给定一个数字 n，找出可形成完整阶梯行的总行数。

n 是一个非负整数，并且在32位有符号整型的范围内。

思路：
用二分查找法判断到mid位置的前mid个和是否等于n,O(logn)。
最简单的方法，直接遍历到n取值O(n).

代码：

class Solution {
    public int arrangeCoins(int n) {
        long left = 0;long right = n;
        long mid,cur;
        while(left<=right){
            mid = (right + left)/2;
            cur = mid*(1+mid)/2;
            if(cur==n){
                return (int)mid;
            }
            if(cur>n){
                right = mid-1;
            }else{
                left = mid+1;
            }
        }
        return (int)right;
    }
}