496. 下一个更大元素 I(暴力解法)

给你两个 没有重复元素 的数组 nums1 和 nums2 ,其中nums1 是 nums2 的子集。

请你找出 nums1 中每个元素在 nums2 中的下一个比其大的值。

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在,对应位置输出 -1 。

示例 1:

输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
    对于 num1 中的数字 4 ,你无法在第二个数组中找到下一个更大的数字,因此输出 -1 。
    对于 num1 中的数字 1 ,第二个数组中数字1右边的下一个较大数字是 3 。
    对于 num1 中的数字 2 ,第二个数组中没有下一个更大的数字,因此输出 -1 。
示例 2:

输入: nums1 = [2,4], nums2 = [1,2,3,4].
输出: [3,-1]
解释:
    对于 num1 中的数字 2 ,第二个数组中的下一个较大数字是 3 。
    对于 num1 中的数字 4 ,第二个数组中没有下一个更大的数字,因此输出 -1 。
 

提示:

1 <= nums1.length <= nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 104
nums1和nums2中所有整数 互不相同
nums1 中的所有整数同样出现在 nums2 中

来源:力扣(LeetCode)
 

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        stack<int> stack_data;
        vector<int> data;
        for (auto iter1 = nums1.begin(); iter1 != nums1.end(); iter1++) {
            for (int size = (int)nums2.size() - 1; size >= 0 && *iter1 != nums2[size];size--){
                stack_data.push(nums2[size]);
            }
            if (!stack_data.empty()) {
                while (*iter1 > stack_data.top()) {
                    stack_data.pop();
                    if (stack_data.empty()) {
                        break;
                    }
                }
            }
            if (!stack_data.empty()) {
                data.push_back(stack_data.top());
            }
            else {
                data.push_back(-1);
            }
            while (!stack_data.empty()) {
                stack_data.pop();
            }
        }
        return data;
    }
};

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是一个简单的例子,使用对称下三角一维存储和Jacobi迭代方法求解大型有限元方程的C语言代码: ```c #include <stdio.h> #include <stdlib.h> #include <math.h> #define N 1000 // 方程的维数 #define MAX_ITER 1000 // 最大迭代次数 #define TOL 1e-6 // 收敛精度 int main() { double *a, *b, *x, *r, *d; int *ia, *ja; int i, j, k, iter; double sum, norm, rho, alpha; // 分配内存 a = (double*)malloc(N*(N+1)/2*sizeof(double)); b = (double*)malloc(N*sizeof(double)); x = (double*)malloc(N*sizeof(double)); r = (double*)malloc(N*sizeof(double)); d = (double*)malloc(N*sizeof(double)); ia = (int*)malloc((N+1)*sizeof(int)); ja = (int*)malloc(N*(N+1)/2*sizeof(int)); // 初始化 for(i=0; i<N*(N+1)/2; i++) a[i] = 0; for(i=0; i<N; i++) { b[i] = 1; x[i] = 0; r[i] = b[i]; d[i] = r[i]; } // 构建矩阵 k = 0; for(i=0; i<N; i++) { ia[i] = k; for(j=0; j<=i; j++) { ja[k] = j; a[k] = 1.0/(i+j+1); k++; } } ia[N] = k; // Jacobi迭代 norm = 0; for(i=0; i<N; i++) norm += r[i]*r[i]; iter = 0; while(norm > TOL*TOL && iter < MAX_ITER) { // 计算Ad for(i=0; i<N; i++) { sum = 0; for(k=ia[i]; k<ia[i+1]; k++) sum += a[k]*d[ja[k]]; r[i] = b[i] - sum; } // 计算alpha rho = 0; for(i=0; i<N; i++) rho += r[i]*r[i]; alpha = 0; for(i=0; i<N; i++) alpha += d[i]*r[i]; alpha /= rho; // 更新x和r norm = 0; for(i=0; i<N; i++) { x[i] += alpha*d[i]; r[i] -= alpha*a[ia[i]]*d[i]; norm += r[i]*r[i]; } // 计算beta rho = 0; for(i=0; i<N; i++) rho += r[i]*r[i]; norm /= rho; for(i=0; i<N; i++) d[i] = r[i] + norm*d[i]; iter++; } // 打印结果 printf("Number of iterations: %d\n", iter); for(i=0; i<N; i++) printf("x[%d] = %e\n", i, x[i]); // 释放内存 free(a); free(b); free(x); free(r); free(d); free(ia); free(ja); return 0; } ``` 在这个例子中,我们使用了对称下三角一维存储方式,即将矩阵的下三角部分按行压缩成一维数组。对于一个维数为N的矩阵,其下三角元素的个数为N*(N+1)/2。我们将这些元素存储在一个一维数组a中,按照行优先的顺序排列。对于a中第i个元素,它对应着矩阵的第ia[i]行和第ja[i]列的元素。 在Jacobi迭代中,我们使用了以下公式: x^(k+1) = x^k + alpha^k * d^k d^(k+1) = r^(k+1) + beta^k * d^k 其中,x^(k)表示第k次迭代的解向量,r^(k)表示第k次迭代的残差向量,d^(k)表示第k次迭代的搜索方向向量,alpha^k表示第k次迭代的步长,beta^k表示第k次迭代的搜索方向向量的缩放系数。 在代码中,我们首先计算Ad,然后计算alpha,更新x和r,最后计算beta和更新d。迭代终止的条件是残差的平方和小于收敛精度的平方或者达到最大迭代次数。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值