454.四数相加II
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
解题步骤：
- 创建一个哈希表
sumCount，用于记录每个和的出现次数。 - 使用两个嵌套的循环遍历
nums1和nums2，计算并记录所有nums1[i] + nums2[j]的和及其出现次数。将和作为键，出现次数作为值存入sumCount。 - 再次使用两个嵌套的循环遍历
nums3和nums4，计算-(nums3[k] + nums4[l])的值，并查找sumCount中是否存在该值。如果存在，则将对应的出现次数累加到结果中。 - 返回结果作为满足条件的元组数量。
//LeetCode执行通过，但提交编译失败
int fourSumCount(int* nums1, int nums1Size, int* nums2, int nums2Size, int* nums3, int nums3Size, int* nums4, int nums4Size) {
int sumCount[2001] = {0}; // 声明一个大小为2001的数组sumCount，用于记录每个和的出现次数。初始化为0。
int count = 0; // 初始化计数器count为0，用于记录满足条件的元组数量。
// 遍历nums1和nums2，计算并记录所有nums1[i] + nums2[j]的和及其出现次数。将和作为下标，出现次数作为值存入sumCount数组中。
for (int i = 0; i < nums1Size; i++) {
for (int j = 0; j < nums2Size; j++) {
sumCount[nums1[i] + nums2[j] + 1000]++; // 使用和+1000作为下标，并将对应位置的值加1。
}
}
// 再次遍历nums3和nums4，计算-(nums3[k] + nums4[l])的值，并查找sumCount数组中是否存在该值。
// 如果存在，则将对应位置的值累加到计数器count中。
for (int k = 0; k < nums3Size; k++) {
for (int l = 0; l < nums4Size; l++) {
int target = -(nums3[k] + nums4[l]) + 1000; // 计算目标值
count += sumCount[target]; // 累加满足条件的元组数量
}
}
return count; // 返回满足条件的元组数量
}
#define HASH_SIZE 10007
typedef struct HashNode {
int key;
int val;
struct HashNode* next;
} HashNode;
HashNode* createNode(int key, int val) {
HashNode* node = (HashNode*)malloc(sizeof(HashNode));
node->key = key;
node->val = val;
node->next = NULL;
return node;
}
void addToHashTable(HashNode** hashTable, int key, int val) {
int index = abs(key) % HASH_SIZE;
HashNode* node = hashTable[index];
while (node != NULL) {
if (node->key == key) {
node->val += val;
return;
}
node = node->next;
}
HashNode* newNode = createNode(key, val);
newNode->next = hashTable[index];
hashTable[index] = newNode;
}
int findInHashTable(HashNode** hashTable, int key) {
int index = abs(key) % HASH_SIZE;
HashNode* node = hashTable[index];
while (node != NULL) {
if (node->key == key) {
return node->val;
}
node = node->next;
}
return 0;
}
int fourSumCount(int* nums1, int nums1Size, int* nums2, int nums2Size, int* nums3, int nums3Size, int* nums4, int nums4Size) {
int count = 0;
HashNode** hashTable = (HashNode**)malloc(HASH_SIZE * sizeof(HashNode*));
memset(hashTable, 0, HASH_SIZE * sizeof(HashNode*));
// 计算第一组数组中每个数的出现次数
for (int i = 0; i < nums1Size; i++) {
for (int j = 0; j < nums2Size; j++) {
addToHashTable(hashTable, nums1[i] + nums2[j], 1);
}
}
// 枚举第三组数组和第四组数组中的数
for (int i = 0; i < nums3Size; i++) {
for (int j = 0; j < nums4Size; j++) {
count += findInHashTable(hashTable, -(nums3[i] + nums4[j]));
}
}
// 释放哈希表空间
for (int i = 0; i < HASH_SIZE; i++) {
HashNode* node = hashTable[i];
while (node != NULL) {
HashNode* temp = node;
node = node->next;
free(temp);
}
}
free(hashTable);
return count;
}
java写法
class Solution {
public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
int res = 0;
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
//统计两个数组中的元素之和，同时统计出现的次数，放入map
for (int i : nums1) {
for (int j : nums2) {
int sum = i + j;
map.put(sum, map.getOrDefault(sum, 0) + 1);
}
}
//统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数
for (int i : nums3) {
for (int j : nums4) {
res += map.getOrDefault(0 - i - j, 0);
}
}
return res;
}
}383. 赎金信
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
通过一个长度为26的数组 count 来统计杂志字符串中每个字符的出现次数。遍历赎金信字符串，并逐个检查字符是否在杂志字符串中有足够的数量。如果某个字符的数量不够，就返回 false；否则，最后返回 true 表示赎金信可以由杂志字符串构成。
bool canConstruct(char* ransomNote, char* magazine) {
int ransomLen = strlen(ransomNote);
int magLen = strlen(magazine);
// 统计杂志字符串中每个字符的出现次数
int count[26] = {0};
for (int i = 0; i < magLen; i++) {
count[magazine[i] - 'a']++;
}
// 检查赎金信字符串字符在杂志字符串中是否有足够的数量
for (int i = 0; i < ransomLen; i++) {
if (count[ransomNote[i] - 'a'] == 0) {
return false;
}
count[ransomNote[i] - 'a']--;
}
return true;
}
java写法
class Solution {
public boolean canConstruct(String ransomNote, String magazine) {
// shortcut
if (ransomNote.length() > magazine.length()) {
return false;
}
// 定义一个哈希映射数组
int[] record = new int[26];
// 遍历
for(char c : magazine.toCharArray()){
record[c - 'a'] += 1;
}
for(char c : ransomNote.toCharArray()){
record[c - 'a'] -= 1;
}
// 如果数组中存在负数，说明ransomNote字符串总存在magazine中没有的字符
for(int i : record){
if(i < 0){
return false;
}
}
return true;
}
}
15. 三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
双指针法来解决这个问题：首先对 nums 数组进行排序，假设当前处理的元素是 nums[i]，那么我们可以从左右两端分别取一个元素 nums[left] 和 nums[right]，计算它们的和 sum。如果 sum 小于0，则说明 left 指向的元素太小，我们将 left 指针右移一位；如果 sum 大于0，则说明 right 指向的元素太大，我们将 right 指针左移一位；如果 sum 等于0，则说明我们找到了一组解，将其存入答案数组中，并继续寻找其他解。
（在这个过程中，我们需要注意去重的问题，即跳过相同的元素。）
// 定义比较函数，用于排序
int cmp(const void* ptr1, const void* ptr2) {
return *((int*)ptr1) - *((int*)ptr2);
}
// 求解三数之和为0的问题
int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
// 开辟一个二维数组用于存放结果
int **ans = (int**)malloc(sizeof(int*) * 18000);
int ansTop = 0;
// 若传入nums数组大小小于3，则需要返回数组大小为0
if(numsSize < 3) {
*returnSize = 0;
return ans;
}
// 对nums数组进行排序
qsort(nums, numsSize, sizeof(int), cmp);
int i;
// 用for循环遍历数组，结束条件为i < numsSize - 2(因为要预留左右指针的位置)
for(i = 0; i < numsSize - 2; i++) {
// 若当前i指向元素>0，则代表left和right以及i的和大于0。直接break
if(nums[i] > 0)
break;
// 去重：i > 0 && nums[i] == nums[i-1]
if(i > 0 && nums[i] == nums[i-1])
continue;
// 定义左指针和右指针
int left = i + 1;
int right = numsSize - 1;
// 当右指针比左指针大时进行循环
while(right > left) {
// 求出三数之和
int sum = nums[right] + nums[left] + nums[i];
// 若和小于0，则左指针+1（因为左指针右边的数比当前所指元素大）
if(sum < 0)
left++;
// 若和大于0，则将右指针-1
else if(sum > 0)
right--;
// 若和等于0
else {
// 开辟一个大小为3的数组空间，存入nums[i], nums[left]和nums[right]
int* arr = (int*)malloc(sizeof(int) * 3);
arr[0] = nums[i];
arr[1] = nums[left];
arr[2] = nums[right];
// 将开辟数组存入ans中
ans[ansTop++] = arr;
// 去重
while(right > left && nums[right] == nums[right - 1])
right--;
while(left < right && nums[left] == nums[left + 1])
left++;
// 更新左右指针
left++;
right--;
}
}
}
// 设定返回的数组大小
*returnSize = ansTop;
*returnColumnSizes = (int*)malloc(sizeof(int) * ansTop);
int z;
for(z = 0; z < ansTop; z++) {
(*returnColumnSizes)[z] = 3;
}
return ans;
}
java写法
class Solution {
public List<List<Integer>> threeSum(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums);
// 找出a + b + c = 0
// a = nums[i], b = nums[left], c = nums[right]
for (int i = 0; i < nums.length; i++) {
// 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
if (nums[i] > 0) {
return result;
}
if (i > 0 && nums[i] == nums[i - 1]) { // 去重a
continue;
}
int left = i + 1;
int right = nums.length - 1;
while (right > left) {
int sum = nums[i] + nums[left] + nums[right];
if (sum > 0) {
right--;
} else if (sum < 0) {
left++;
} else {
result.add(Arrays.asList(nums[i], nums[left], nums[right]));
// 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
right--;
left++;
}
}
}
return result;
}
}18. 四数之和
给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
int temp(const void* a1, const void* a2)
{
return *(int*)a1 - *(int*)a2; // 升序
}
int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** returnColumnSizes)
{
qsort(nums, numsSize, sizeof(int), temp); // 对数组进行升序排序
int base = 48;
int** ret = malloc(sizeof(int*) * base); // 分配存储结果的二维数组内存空间
*returnColumnSizes = (int*)malloc(sizeof(int) * base); // 分配存储每个四元组的列数的空间
*returnSize = 0; // 初始化返回结果的个数为0
int l, r; // 定义左指针和右指针
for(int i = 0; i < numsSize; i++)
{
if(i > 0 && nums[i] == nums[i-1])
{
continue; // 如果当前数与前一个数相同，跳过该次循环
}
for(int j = i + 1; j < numsSize; j++)
{
if(j > i + 1 && nums[j] == nums[j-1])
{
continue; // 如果当前数与前一个数相同，跳过该次循环
}
l = j + 1; // 左指针从j的下一个位置开始
r = numsSize - 1; // 右指针从数组末尾开始
while(l < r)
{
long sum = (long)nums[i] + (long)nums[j] + (long)nums[l] + (long)nums[r]; // 四数之和
if(sum == target)
{
ret[(*returnSize)] = malloc(sizeof(int) * 4); // 分配存储四元组的空间
(*returnColumnSizes)[(*returnSize)] = 4; // 设置当前四元组的列数为4
ret[(*returnSize)][0] = nums[i]; // 存储第一个数
ret[(*returnSize)][1] = nums[j]; // 存储第二个数
ret[(*returnSize)][2] = nums[r]; // 存储第三个数
ret[(*returnSize)][3] = nums[l]; // 存储第四个数
(*returnSize)++; // 返回结果个数加1
if((*returnSize) == base)
{
base *= 2; // 如果返回结果个数达到当前分配的大小，扩大分配空间
ret = realloc(ret, sizeof(int*) * base); // 扩大存储结果的二维数组空间
*returnColumnSizes = (int*)realloc(*returnColumnSizes, sizeof(int) * base); // 扩大存储列数的数组空间
}
int num1 = nums[l], num2 = nums[r];
while(num1 == nums[l] && l < r)
{
l++; // 跳过重复的数
}
while(num2 == nums[r] && l < r)
{
r--; // 跳过重复的数
}
}
else if(sum > target)
{
r--; // 四数之和大于目标值，右指针左移
}
else
{
l++; // 四数之和小于目标值，左指针右移
}
}
}
}
return ret; // 返回结果数组
}
java写法
class Solution {
public List<List<Integer>> fourSum(int[] nums, int target) {
List<List<Integer>> result = new ArrayList<>();
Arrays.sort(nums);
for (int i = 0; i < nums.length; i++) {
// nums[i] > target 直接返回, 剪枝操作
if (nums[i] > 0 && nums[i] > target) {
return result;
}
if (i > 0 && nums[i - 1] == nums[i]) { // 对nums[i]去重
continue;
}
for (int j = i + 1; j < nums.length; j++) {
if (j > i + 1 && nums[j - 1] == nums[j]) { // 对nums[j]去重
continue;
}
int left = j + 1;
int right = nums.length - 1;
while (right > left) {
// nums[k] + nums[i] + nums[left] + nums[right] > target int会溢出
long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
if (sum > target) {
right--;
} else if (sum < target) {
left++;
} else {
result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
// 对nums[left]和nums[right]去重
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
left++;
right--;
}
}
}
}
return result;
}
}
526
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
