编程题实战记录

1.题目：

一个整数可以由连续的自然数之和来表示 给定一个整数

计算该整数有几种连续自然数之和的表达式

并打印出每一种表达式

输入描述

一个目标整数t 1<= t <=1000

输出描述

1.该整数的所有表达式和表达式的个数

如果有多种表达式，自然数个数最少的表达式优先输出

2.每个表达式中按自然数递增输出

具体的格式参见样例

在每个测试数据结束时，输出一行"Result:X"

其中X是最终的表达式个数

输入

9

输出

9=9

9=4+5

9=2+3+4

Result:3

说明 整数9有三种表达方法：

示例二

输入

10

输出

10=10

10=1+2+3+4

Result:2

代码粘贴:
public static void main(String[] args) {
    int a=10;
    int count=0;
    for(int j=1;j<a;j++) {
        for (int n = 1; n <=a; n++) {
            if((j*n+(1+j-1)*(j-1)/2)==a){
                StringBuffer str=new StringBuffer(a+"=");
               for(int m=0;m<j;m++){
                   if(m==0) {
                       str.append(n + m);
                   }else{
                       str.append("+"+(n + m));
                   }
               }
                System.out.println(str);
               count++;
            }
        }
    }
    System.out.println("Result:"+count);
}

2 题目:.给定两个整数数组array1、array2，数组元素按升序排列。假设从array1、array2中分别取出一个元素可构成一对元素，现在需要取出k对元素，并对取出的所有元素求和，计算和的最小值 注意：两对元素如果对应于array1、array2中的两个下标均相同，则视为同一对元素。 输入描述: 输入两行数组array1、array2，每行首个数字为数组大小size(0 < size <= 100); 0 < array1[i] <= 1000 0 < array2[i] <= 1000 接下来一行为正整数k 0 < k <= array1.size() * array2.size() 输出描述: 满足要求的最小和 示例1 输入 3 1 1 2 3 1 2 3 2 输出 4 说明 用例中，需要取2对元素 取第一个数组第0个元素与第二个数组第0个元素组成1对元素[1,1]; 取第一个数组第1个元素与第二个数组第0个元素组成1对元素[1,1]; 求和为1+1+1+1=4，为满足要求的最小和 

PS：这道理目前两个思路，一个是利用优先队列(最小堆)PriorityQueue实现，塞入两个元素对应的下标之前通过元素和进行大小比较，优先offer到queue头部，达成有序队列，计算sum的时候再以此从头部poll出（queue可以存储map，Pair，Tuple，也可以二元压缩一元的矩阵思路）

• 在二维数组中，假设有 m 行 n 列，即总共有 m * n 个元素。
• 二维数组中的元素可以用二维索引 [i, j] 来表示，其中 i 表示行号，j 表示列号。
• 为了将二维数组映射到一维数组，可以将二维索引 [i, j] 映射为一维索引 index。
• 一维数组中的元素可以用一维索引 index 来表示，范围通常是 0 到 m * n - 1。
• 为了实现二维到一维的映射，可以使用公式 index = i * n + j，其中 n 表示二维数组的列数。

index = i * n + j

i = index / n
j = index % n

代码粘贴：

public static void main(String[] args) {
    int[] array1 = {1, 1, 2};
    int[] array2 = {1, 2, 3};
    int k = 2;
    int result = minSum(array1, array2, k);
    System.out.println(result);
}

public static int minSum(int[] array1, int[] array2, int k) {
    PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> array1[a] + array2[b] - array1[b] - array2[a]);
    for (int i = 0; i < array1.length; i++) {
        for (int j = 0; j < array2.length; j++) {
            pq.offer(i * array2.length + j);
        }
    }
    int sum = 0;
    for (int i = 0; i < k; i++) {
        int index = pq.poll();
        sum += array1[index / array2.length] + array2[index % array2.length];
    }

    return sum;
}
}

思路二：动态规划，比较麻烦，不推荐。