Leetcode11 盛最多水的容器
给定 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i
的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。说明：你不能倾斜容器，且 n 的值至少为 2。
图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例:
输入: [1,8,6,2,5,4,8,3,7] 输出: 49
思路：一开始我用暴力法直接解题，然后一顿操作猛如虎。一看打败的人只有百分之三十。。。也对，怎么可能暴力法是最优解呢。。
这道题可以用双指针法完成，一个指针指向最初的端点，一个指向最后，然后把两个指针向中央移动，并不断更新最大值，这样在指针碰撞之前，我们能够得到一个最大值，该值为我们所求。有一点需要注意，我们把指针向中央移动时，移动的是比较短的那个。为什么呢？我们都知道，面积为长度与宽度之积。随着指针向中央移动，其长度必定递减，为求更大的面积，我们必须要求更大的宽度。而我们又知，所求的宽度取决于更短的那个（木桶原理），若要宽度增大，我们唯有移动更短的端点，唯有这样才有使宽度增大的希望，才有使面积增大的希望。
class Solution {
public int maxArea(int[] height) {
int i = 0,j = height.length - 1,max = 0,now = 0;
while(i != j){
now = (j - i) * Math.min(height[i],height[j]);
max = max > now ? max : now;
if(height[i] >= height[j]){
j--;
}else{
i++;
}
}
return max;
}
}
Leetcode12 整数转罗马数字
罗马数字包含以下七种字符： 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.
class Solution {
public String intToRoman(int num) {
String[] array = {"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
int[] number = {1000,900,500,400,100,90,50,40,10,9,5,4,1};
int i = 0;
String get = "";
while(i <= 12){
if(num >= number[i]){
num -= number[i];
get += array[i];
}else{
i++;
}
}
return get;
}
}
Leetcode13 罗马数字转整数
罗马数字包含以下七种字符: 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.
class Solution {
public int romanToInt(String s) {
String[] array = {"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
int[] number = {1000,900,500,400,100,90,50,40,10,9,5,4,1};
int i = 0,num = 0;
while(!s.equals("")){
if(s.startsWith(array[i])){
s = s.substring((array[i]).length());
num += number[i];
}else{
i++;
}
}
return num;
}
}
Leetcode14 最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。
示例 1:
输入: [“flower”,“flow”,“flight”] 输出: “fl”
示例 2:输入: [“dog”,“racecar”,“car”] 输出: “”
解释: 输入不存在公共前缀。
说明:所有输入只包含小写字母 a-z 。
解析：遍历每一个字符串，比较当前最大公共前缀的字符串与当前字符串是否相等，不相等则更新最大公共前缀的字符串即可。
class Solution {
public String longestCommonPrefix(String[] strs) {
if(strs == null || strs.length == 0){
return "";
}
String max = strs[0];//最长公共前缀
int num = strs[0].length();//最长公共前缀的长度
int length = 0;//当前遍历的字符串长度与最长公共前缀的长度最小值
int i,j;
for(i = 1;i < strs.length;i++){
length = strs[i].length() > num ? num : strs[i].length();
for(j = 0;j < length;j++){
if(max.charAt(j) != strs[i].charAt(j)){
max = max.substring(0,j);
if(max.equals("")){
return "";
}
num = j;
break;
}
}
if(num > j) {
max = max.substring(0,j);
num = j;
}
}
return max;
}
}
Leetcode15 三数之和
给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0
？找出所有满足条件且不重复的三元组。注意：答案中不可以包含重复的三元组。
例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]
解析：使用双指针法，由于要取三数之和，可以先将数组排序，然后遍历数组取出第一个数字，然后建立两个指针，分别指向第一个数字之后的一个数字和最后一个数字，判断三数之和是否为0，是则添加至链表，否则继续移动双指针，注意判断边界条件和去重即可。
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> list = new ArrayList<List<Integer>>();
if(nums == null){
return null;
}else if(nums.length < 3){
return list;
}
int j,k;
Arrays.sort(nums);//排序
for(int i = 0;i < nums.length - 2;i++){
if(nums[i] > 0){//首数字大于0，易知三数之和不可能等于0
break;
}
if(i > 0 && nums[i] == nums[i-1]){//去重
continue;
}
j = i + 1;
k = nums.length - 1;
while(j < k){
if(nums[i] + nums[j] + nums[k] == 0){
if(j > i + 1 && nums[j] == nums[j-1]){//去重
j++;
}else if(k < nums.length - 1 && nums[k] == nums[k+1]){//去重
k--;
}else{
list.add(Arrays.asList(nums[i],nums[j],nums[k]));
j++;
k--;
}
}else if(nums[i] + nums[j] + nums[k] > 0 && j < k - 1){
k--;
}else if(nums[i] + nums[j] + nums[k] < 0 && j < k - 1){
j++;
}else {
break;
}
}
}
return list;
}
}
Leetcode16 最接近的三数之和
给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.
与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).
解析：这一题运用双指针法可以轻松解决，由于这一题与上题十分相似，故不重复解题思路了。
class Solution {
public int threeSumClosest(int[] nums, int target) {
Arrays.sort(nums);//排序
int j,k,num = nums[0] + nums[1] + nums[nums.length-1];//num为三数之和
for(int i = 0;i < nums.length - 2;i++){
if(i > 0 && nums[i] == nums[i-1]){//去重
continue;
}
j = i + 1;
k = nums.length - 1;
while(j < k){
int sum = nums[i] + nums[j] + nums[k];
if(Math.abs(target - sum) < Math.abs(target - num)) {
num = sum;
}
if(sum > target) {
k--;
}else if(sum < target) {
j++;
}else {
return target;
}
}
}
return num;
}
}
Leetcode17 电话号码的字母组合
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
示例:
输入：“23”
输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”].
说明:
尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。
解析：实话实说，这道题挺简单的，真的没啥好说的。。。
class Solution {
public List<String> letterCombinations(String digits) {
List<String> list = new ArrayList<String>();
if(digits == null){
return null;
}else if(digits.length() == 0){
return list;
}
char[] chArray = digits.toCharArray();
char[][] getArray = {{'a','b','c'},{'d','e','f'},{'g','h','i'},{'j','k','l'},{'m','n','o'},{'p','q','r','s'},{'t','u','v'},{'w','x','y','z'}};
int[] x = new int[chArray.length];
int all = 1;
for(int i = 0;i < chArray.length;i++){
if(chArray[i] == '7' || chArray[i] == '9'){
all *= 4;
x[i] = 4;
}else{
all *= 3;
x[i] = 3;
}
}
int least = all,j,k,num;
char[][] arr = new char[all][chArray.length];
for(int i = 0;i < chArray.length;i++){
least /= x[i];
num = least;
j = 0;
k = 0;
while(j < all){
for(;j < num;j++){
arr[j][i] = getArray[chArray[i] - '2'][k];
}
num += least;
k = k == x[i] - 1 ? 0 : k + 1;
}
}
for(int i = 0;i < all;i++){
list.add(new String(arr[i]));
}
return list;
}
}
Leetcode19 删除链表的倒数第N个节点
给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
示例：
给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：
给定的 n 保证是有效的。
解析：使用快慢指针
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode left = head,right = head,p = null;//p为left的前一个节点
int i = 0;
while(right.next != null){
right = right.next;
if(++i >= n){
p = left;
left = left.next;
}
}
//left为要删除的节点
if(p == null){
return head.next;
}else{
p.next = left.next;
}
return head;
}
}
Leetcode20 有效的括号
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: “()”
输出: true
示例 2:
输入: “()[]{}”
输出: true
示例 3:
输入: “(]”
输出: false
示例 4:
输入: “([)]”
输出: false
示例 5:
输入: “{[]}”
输出: true
解析：堆栈的基本应用
class Solution {
public boolean isValid(String s) {
if(s.length() == 0){
return true;
}
Stack<Character> stack = new Stack<Character>();
char[] charArray = s.toCharArray();
for(int i = 0;i < charArray.length;i++){
if(charArray[i] == '(' || charArray[i] == '{' || charArray[i] == '['){
stack.push(charArray[i]);
}else if(charArray[i] == ')'){
if(stack.empty() || stack.pop() != '('){
return false;
}
}else if(charArray[i] == '}'){
if(stack.empty() || stack.pop() != '{'){
return false;
}
}else if(charArray[i] == ']'){
if(stack.empty() || stack.pop() != '['){
return false;
}
}
}
if(stack.empty()){
return true;
}
return false;
}
}
扫一扫
344
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
