要解决这个问题，我们可以使用动态规划的方法。首先，我们需要创建一个二维数组dp,其中dpi表示从数组的前i个元素中选取若干个元素(最多j个),使得它们的和最大。然后，我们可以遍历数组，对于每个元素，我们可以选择包含它或者不包含它。如果我们选择包含它，那么我们需要更新dp数组中前i-1个元素的最大子序列和；如果我们选择不包含它，那么我们需要更新dp数组中前i-1个元素的最大子序列和。最后，我们返回dp数组的最后一个元素即可。

以下是Java代码实现：

public int maxNonContiguousSubsequenceSum(int[] nums) {
    int n = nums.length;
    if (n == 0) {
        return 0;
    }
    if (n == 1) {
        return nums[0];
    }
    if (n == 2) {
        return Math.max(nums[0], nums[1]);
    }

    int[][] dp = new int[n][n];
    for (int i = 0; i < n; i++) {
        dp[i][0] = nums[i];
    }
    dp[0][1] = Math.max(nums[0], nums[1]);

    for (int i = 2; i < n; i++) {
        for (int j = 1; j <= i; j++) {
            dp[i][j] = Math.max(dp[i - 1][j], nums[i] + dp[i - j][j]);
        }
    }

    return dp[n - 1][n];
}

这段代码首先定义了一个二维数组dp,并初始化了边界情况。然后，通过两层循环遍历数组，更新dp数组的值。最后，返回dp数组的最后一个元素作为结果。