可以使用动态规划来解决这个问题。首先，我们定义一个二维数组dp，其中dpi表示进行i次操作后，数组中前j个元素的最大和。

然后，我们可以根据题目要求进行状态转移。对于第i次操作，我们可以选择数组中的两个元素ai和aj，使得ai×aj的值最大。假设我们选择了ai和aj，那么我们可以将ai替换为x，aj替换为y，使得x×y=ai×aj。此时，数组中的元素总和增加了(x+y-ai-aj)。

因此，我们可以得到状态转移方程：
dpi = max(dpi, dpi-1 + (x+y-ai-aj))

其中，p表示在第i-1次操作后，数组中的第p个元素与第j个元素进行了操作，使得ai×aj的值最大。

最后，我们可以遍历所有的i和j的组合，计算出dpk的最大值，即为最终的结果。

下面是Java代码的实现：

public class Solution {
    public int maxSumAfterOperations(int[] nums, int k) {
        int n = nums.length;
        int[][] dp = new int[k+1][n+1];
        
        for (int i = 1; i <= k; i++) {
            for (int j = 2; j <= n; j++) {
                int maxSum = 0;
                for (int p = 1; p < j; p++) {
                    int x = gcd(nums[p-1], nums[j-1]);
                    int y = nums[j-1] / x;
                    maxSum = Math.max(maxSum, dp[i-1][p] + (x+y-nums[p-1]-nums[j-1]));
                }
                dp[i][j] = Math.max(dp[i][j-1], maxSum);
            }
        }
        
        return dp[k][n];
    }
    
    private int gcd(int a, int b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }
}

其中，gcd函数用于计算两个数的最大公约数。