1 5 11 5

true

1 2 3 5

false

#include <iostream>
#include <vector>
using namespace std;

// 使用 Solution 类包装功能函数
class Solution {
public:
    // 判断是否可以分割成两个和相等的子集
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        // 计算数组总和 $S$
        for (int num : nums) {
            sum += num;
        }
        // 如果 $S$ 为奇数，则不能分割
        if (sum % 2 != 0) return false;
        int target = sum / 2; // 目标和 $T$
        
        // 动态规划数组，$dp[i]$ 表示是否存在子集和为 $i$
        vector<bool> dp(target + 1, false);
        dp[0] = true; // 空集和为 $0$
        
        // 遍历每个元素
        for (int num : nums) {
            // 倒序遍历保证每个元素只被使用一次
            for (int i = target; i >= num; i--) {
                dp[i] = dp[i] || dp[i - num];
            }
        }
        return dp[target];
    }
};

int main(){
    int x;
    vector<int> nums;
    // 读取输入数据（ACM 模式）
    while (cin >> x) {
        nums.push_back(x);
    }
    Solution sol;
    // 输出结果，符合题目要求的格式
    cout << (sol.canPartition(nums) ? "true" : "false");
    return 0;
}

# 定义 Solution 类，包含判断是否可以分割的方法
class Solution:
    # 判断是否可以分割成两个和相等的子集
    def canPartition(self, nums: list[int]) -> bool:
        total = sum(nums)  # 计算数组总和 $S$
        if total % 2 != 0:
            return False  # 如果 $S$ 为奇数，则不能分割
        target = total // 2  # 目标和 $T$
        
        # 初始化动态规划数组，$dp[i]$ 表示是否存在子集和为 $i$
        dp = [False] * (target + 1)
        dp[0] = True  # 空集和为 $0$
        
        # 遍历数组中的每个元素
        for num in nums:
            # 倒序遍历确保每个元素只使用一次
            for i in range(target, num - 1, -1):
                dp[i] = dp[i] or dp[i - num]
        return dp[target]

if __name__ == "__main__":
    import sys
    # 读取所有输入数据
    nums = list(map(int, sys.stdin.read().split()))
    sol = Solution()
    # 输出结果，符合题目要求的格式
    print("true" if sol.canPartition(nums) else "false")

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    // 判断是否可以分割成两个和相等的子集
    public static boolean canPartition(int[] nums) {
        int sum = 0;
        // 计算数组总和 $S$
        for (int num : nums) {
            sum += num;
        }
        // 如果 $S$ 为奇数，则不能分割
        if (sum % 2 != 0) {
            return false;
        }
        int target = sum / 2;  // 目标和 $T$
        
        // 初始化动态规划数组，$dp[i]$ 表示是否存在子集和为 $i$
        boolean[] dp = new boolean[target + 1];
        dp[0] = true;  // 空集和为 $0$
        
        // 遍历数组中的每个元素
        for (int num : nums) {
            // 倒序遍历保证每个元素只使用一次
            for (int i = target; i >= num; i--) {
                dp[i] = dp[i] || dp[i - num];
            }
        }
        return dp[target];
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<Integer> list = new ArrayList<>();
        // 读取所有输入数据（ACM 模式）
        while (sc.hasNextInt()) {
            list.add(sc.nextInt());
        }
        int[] nums = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            nums[i] = list.get(i);
        }
        // 输出结果，符合题目要求的格式
        System.out.println(canPartition(nums) ? "true" : "false");
    }
}