文章目录
- 第一天
- 217. 存在重复元素
- 53.最大子数组和
- 第二天
- 1. 两数之和
- 88. 合并两个有序数组
第一天
217. 存在重复元素
题解思路：首先题目需要的是判断数组中是否存在相同的数字，存在返回true,不存在就返回false。
那么显然可以这样做，先进行排序（从小到大或从大到小均可），之后进行遍历，如果相邻两个的数值相等的话就是返回true，说明有相等的数值，否则全部遍历完之后没有相等就返回false。我们知道Java中有Arrays.sort()可以对数组进行排序，默认如果是数字的话就是从小到大，如果是字符的话就是按照字典序的顺序进行排序。
代码（力扣模板模式）
class Solution {
public boolean containsDuplicate(int[] nums) {
Arrays.sort(nums);//从小到大排序
for(int i=0;i<nums.length-1;i++){
if(nums[i]==nums[i+1]){//进行比较
return true;
}
}
return false;
}
}
代码（竞赛模式）
import java.util.Arrays;
import java.util.Scanner;
public class sorf_217_tijie {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();//先输入一个字符串，以逗号分割
String[] strArr = str.split(",");//以逗号分割成字符串数组
int[] int_str = new int[strArr.length];
for(int i=0;i<strArr.length;i++) {
int_str[i] = Integer.parseInt(strArr[i]);//遍历将字符串数组转化为整型数组
}
Arrays.sort(int_str);//排序
int j=0;
for(;j<strArr.length-1;j++) {
if(int_str[j]==int_str[j+1]) {
System.out.println("true");
break;
}
}
if(j==strArr.length-1) {
System.out.println("false");
}
}
}
53.最大子数组和
解题思路：
首先引用一句话：遍历一个子串或者子序列有三种遍历方式：
1.以某个节点为头的所有子序列，如数组[a,b,c,e]，以a为头的字串为【a】，【a,b】，【a,b,c】，【a,b,c,d】；以b为头的字串为【b】，【b,c】，【b,c,d】……进行遍历
2.以长度为轴进行遍历，如先遍历长度为1的字串，再遍历长度为2的字串……
3.以某个节点为尾的所有字串，如数组[a,b,c,e]，以a为尾的字串为【a】；以b为尾的字串为【a,b】,【b】……进行遍历
其次本题采用第三种遍历方式：即以某个节点为尾的所有字串进行遍历和，假设有数组nums，且dp[i]，表示以第i个数为尾的子串和，则dp[i]=dp[i-1]+nums[i]，而要使得dp[i]是最大的子串的话，就要分在遍历的过程中，如果dp[i-1]为负数，则以第i个数为结尾的字串和即为本身，因为nums[i]加上一个负数都会使得整体值小于nums[i]；dp[i-1]为正数时，此时以第i个数为结尾的字串和最大为dp[i]=dp[i-1]+nums[i]
代码（力扣模板模式）
class Solution {
public int maxSubArray(int[] nums) {
int[] dp = new int[nums.length];//dp[i]表示以i为尾的子串数组最大和
dp[0]=nums[0];
for(int i=1;i<nums.length;i++) {
if(dp[i-1]>0) {
dp[i]=dp[i-1]+nums[i];
}else {
dp[i]=nums[i];
}
}
//求出dp数组中的最大值
Arrays.sort(dp);
return dp[nums.length-1];
}
}
代码（竞赛模式）
import java.util.Arrays;
import java.util.Scanner;
public class 最大子数组和_53 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str1 = sc.next();
String[] str = str1.split(",");
int[] nums = new int[str.length];
for(int i=0;i<nums.length;i++) {
nums[i]=Integer.parseInt(str[i]);
}
System.out.println(maxSubArray(nums));
}
public static int maxSubArray(int[] nums) {
int[] dp = new int[nums.length];//dp[i]表示以i为尾的子串数组最大和
dp[0]=nums[0];
for(int i=1;i<nums.length;i++) {
if(dp[i-1]>0) {
dp[i]=dp[i-1]+nums[i];
}else {
dp[i]=nums[i];
}
}
//求出dp数组中的最大值
Arrays.sort(dp);
return dp[nums.length-1];
}
}
第二天
1. 两数之和
解题思路：
可以使用暴力解法，即两个数，对应两层for循坏进行遍历，判断nums[i]+nums[j]==target即可
代码（力扣模板模式）
class Solution {
public int[] twoSum(int[] nums, int target) {
//定义一个返回值的数组作为存储下标
int[] res = new int[2];
for(int i=0;i<nums.length;i++) {
for(int j=i+1;j<nums.length;j++) {
if(nums[i]+nums[j]==target) {
res[0]=i;
res[1]=j;
return res;
}
}
}
return res;
}
}
代码（竞赛模式）
import java.util.Scanner;
public class 两数之和_1 {
public static void main(String[] args) {
Scanner sc= new Scanner(System.in);
String str1 = sc.next();
String[] str = str1.split(",");
int[] nums = new int[str.length];
for(int i=0;i<str.length;i++) {
nums[i] = Integer.parseInt(str[i]);
}
int target=sc.nextInt();
int[] res = twoSum(nums,target);
System.out.println(res[0]+","+res[1]);
}
public static int[] twoSum(int[] nums, int target) {
//定义一个返回值的数组作为存储下标
int[] res = new int[2];
for(int i=0;i<nums.length;i++) {
for(int j=i+1;j<nums.length;j++) {
if(nums[i]+nums[j]==target) {
res[0]=i;
res[1]=j;
return res;
}
}
}
return res;
}
}
88. 合并两个有序数组
解题思路：直接采用暴力解法，即将第二个数组的元素先拼接进第一个数组的尾部，之后进行排序即可
代码（力扣模板模式）
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
int j = 0;
for(int i=m;i<m+n;i++) {
nums1[i]=nums2[j++];
}
Arrays.sort(nums1);
}
}
代码（竞赛模式）
import java.util.Arrays;
import java.util.Scanner;
public class 合并两个有序数组_88 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//准备两个数组
String str1 = sc.next();
String[] arrStr1 = str1.split(",");
int m = arrStr1.length;//输入作为第一个数组的长度
String str2 = sc.next();
String[] arrStr2 = str2.split(",");
int n = arrStr2.length;//输入作为第一个数组的长度
//进行加长度操作
int[] nums1 = new int[m+n];
int[] nums2 = new int[n];
for(int i=0;i<arrStr1.length;i++) {
nums1[i]=Integer.parseInt(arrStr1[i]);
nums2[i]=Integer.parseInt(arrStr2[i]);
}
merge(nums1,m,nums2,n);
}
public static void merge(int[] nums1, int m, int[] nums2, int n) {
int j = 0;
for(int i=m;i<m+n;i++) {
nums1[i]=nums2[j++];
}
Arrays.sort(nums1);
for(int i=0;i<m+n;i++) {
System.out.print(nums1[i]+" ");
}
}
}
![[Tools: Camera Conventions] NeRF中的相机矩阵估计](https://img-blog.csdnimg.cn/img_convert/9224b3b55a4cadb57779ed7eae814902.png)
