Leetcode 11-15题

盛最多雨水的容器

数组的第\(i\)个数字表示这个位置隔板的高度,选择哪两块板子可以装最多的水,返回可以存储的最大水量。

有一种双指针的贪心策略:如果左边的指针所在的挡板低,就将左边的指针右移,否则将右边的指针左移。

每次移动完之后,计算当前能存储的水量,并和结果值相比较。

证明:假设最优解对应的两条线的下标是 \(i^′,j^′(i^′<j^′)\),在 \(i,j\) 不断靠近的过程中,不妨假设 \(i\) 先走到 \(i^′\),则此时有 \(j^′<j\)。反证,如果此时 \(a_i≤a_j\),设 \(S\) 表示 \(i,j\) 能盛多少水,\(S^′\) 表示 \(i^′,j^′\) 能盛多少水,则:

\[S=min(a_i,a_j)∗(j−i) =a_i∗(j−i) >a_i∗(j^′−i) \geq min(ai,aj^′)∗(j^′−i)=S^′ \]

\(S^′\) 是最优解矛盾,因此 \(a_i>a_j\),所以 \(j\) 会一直走到 \(j^′\),从而得到最优解。

int maxArea(vector<int>& height) {
    int res = 0;
    for(int l = 0, r = height.size() - 1; l < r; ) {
        res = max(res, (r - l) * min(height[l], height[r]));	// 先计算当前状态再转移
        if(height[l] < height[r])   l ++;
        else r --;
    }
    return res;
}

整数转罗马数字

在罗马数字中有如下规则:

I	1
V	5
X	10
L	50
C	100
D	500
M	1000

通常,罗马数字中小的数字在大的数字的右边,如XV表示\(15\)。但也存在特例,如IV表示\(4\),但这只有如下六种情况:

  • I 可以放在 V (5) 和 X (10) 的左边,来表示 4 和 9。
  • X 可以放在 L (50) 和 C (100) 的左边,来表示 40 和 90。
  • C 可以放在 D (500) 和 M (1000) 的左边,来表示 400 和 900。

将给定的数字转化为罗马数字。

1	  	2		3	 	4		5	   	6		 7		   	 8		    9
I	 	II	    III		IV		V	  	VI		 VII		 VIII		IX
10	 	20		30		40		50	  	60		 70			 80		    90
x	 	XX		XXX		XL		L	  	LX		 LXX		 LXXX		XC
100 	200 	300 	400 	500   	600 	 700 		 800 		900
c		CC		CCC		CD		D	  	DC		 DCC		 DCCC		CM
1000	2000	3000
M		MM		MMM

分别枚举个十百千位的数值如何表示,我们不难发现\(1-3\)\(6-8\)的表示比较显然,其余的则比较特殊。

\(100-900\)为例,以\(100,400,500,900\)为界,若\(x>900\)\(x-900\),若\(x>500\)\(x-500\),直至循环结束。

所以只需要打表打出\(1,4,5,9\)系列的值即可,然后从大到小依次减。

string intToRoman(int num) {
    vector<int> key = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
    vector<string> value = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
    string ans = "";
    // 2649 -> 1649 -> 649 -> 149 -> 49	   		-> 9 		-> 0
    // 		   M	   MM     MMD    MMDC     MMDCXL 	MMDCXLIX
    for(int i = 0; i < key.size(); i ++) {
        while(num >= key[i]) {
            num -= key[i];
            ans += value[i];
        }
    }
    return ans;
}

罗马数字转整数

将给定的罗马数字转化为整数。

和上一题类似的打表思想,但是将罗马数字转化为整数时,注意到一个特性:

若大数在小数左边,则为大数+小数,若大数在小数右边,则为大数-小数。并且本题只需要存储7个罗马数字即可。

int romanToInt(string s) {
    unordered_map<char, int> mp;
    mp['I'] = 1;    mp['V'] = 5;    mp['X'] = 10;   mp['L'] = 50;
    mp['C'] = 100;  mp['D'] = 500;  mp['M'] = 1000;

    int ans = 0;
    for(int i = 0; i < s.size(); i ++) {
        if(i + 1 < s.size() && mp[s[i]] < mp[s[i + 1]])
            ans -= mp[s[i]];
        else
            ans += mp[s[i]];
    }
    return ans;
}

最长公共前缀

求字符串数组中的最长公共前缀。

可以用trie树来做,但是太麻烦。

可以直接枚举字符串的每一位,看所有字符串的这一位是否都相同,如果不同就返回当前结果,否则继续下一轮判断。

string longestCommonPrefix(vector<string>& strs) {
    string ans = "";
    for(int i = 0; i < strs[0].size(); i ++) {  // 枚举第i位
        char c = strs[0][i];
        bool flag = true;
        for(auto str : strs) {                  // 判断所有字符串的第i位是否都相同
            if(str.size() < i || str[i] != c) {
                flag = false;
                break;
            }
        }
        if(flag)    ans += c;
        else    break;
    }
    return ans;
}

三数之和

给定整数数组,找出满足\(i \neq j \neq k\)nums[i]+nums[j]+nums[k]=0的所有三元组。

先对整数数组排序,然后枚举\(i\)的所有位置,再对\(j,k\)使用双指针算法。

\(i\)的位置固定后,\(nums[j]+nums[k]=-nums[i]\),当\(j\)右移时,\(k\)必然左移,因此时间复杂度为\(O(n^2)\)

由于答案中不能包含重复的三元组,可以使用set来对答案进行去重。

vector<vector<int>> threeSum(vector<int>& nums) {
    set<vector<int>> res;
    sort(nums.begin(), nums.end());
    for(int i = 0; i < nums.size() - 2; i ++) {     // 固定i
        for(int j = i + 1, k = nums.size() - 1; j < k; j ++) {  // 每次移动j,对j找到满足条件的k
            while(j < k - 1 && nums[i] + nums[j] + nums[k] > 0) k --;
            if(nums[i] + nums[j] + nums[k] == 0)
                res.insert({nums[i], nums[j], nums[k]});
        }
    }
    vector<vector<int>> ans;            // 去重
    for(auto p : res)   ans.push_back(p);
    return ans;
}

对于1 1 2 2 -3这种情况来说,第1个1和第2个1所呈现出的组合是一样的,所以对于相同的数ij都只需要遍历一次即可。

也可以通过这种方法来去重,会大大降低时间复杂度。

vector<vector<int>> threeSum(vector<int>& nums) {
    vector<vector<int>> ans;
    sort(nums.begin(), nums.end());
    for(int i = 0; i < nums.size() - 2; i ++) {     // 固定i
        if(i && nums[i] == nums[i - 1]) continue;   // i不能重复判断 
        for(int j = i + 1, k = nums.size() - 1; j < k; j ++) {  // 每次移动j,对j找到满足条件的k
            if(j > i + 1 && nums[j] == nums[j - 1])  continue;  // j不能重复判断
            // 因为i和j都不会重复,所以k也必然不会重复,所以不需要额外特判k
            while(j < k - 1 && nums[i] + nums[j] + nums[k] > 0) k --;
            if(nums[i] + nums[j] + nums[k] == 0)
                ans.push_back({nums[i], nums[j], nums[k]});
        }
    }
    return ans;
}
posted @ 2024-02-17 19:44  钰见梵星  阅读(35)  评论(0)    收藏  举报