java实现1

有一个由很多木棒构成的集合，每个木棒有对应的长度，请问能否用集合中的这些木棒以某个顺序首尾相连
构成一个面积大于 0
的简单多边形且所有木棒都要用上，简单多边形即不会自交的多边形。
初始集合是空的，有两种操作，要么给集合添加一个长度为 L
的木棒，要么删去集合中已经有的某个木棒。每次操作结束后你都需要告知是否能用集合中的这些木棒构成
一个简单多边形。
输入描述：
每组测试用例仅包含一组数据，每组数据第一行为一个正整数 n 表示操作的数量(1 ≤ n ≤ 50000) ， 接下来有
n行，每行第一个整数为操作类型 i (i ∈ {1,2})，第二个整数为一个长度 L(1 ≤ L ≤ 1,000,000,000)。如果 i=1 代
表在集合内插入一个长度为 L 的木棒，如果 i=2 代表删去在集合内的一根长度为 L 的木棒。输入数据保证删
除时集合中必定存在长度为 L 的木棒，且任意操作后集合都是非空的。
输出描述：
对于每一次操作结束有一次输出，如果集合内的木棒可以构成简单多边形，输出 "Yes" ，否则输出 "No"。
示例1:
输入
5
1 1
1 1
1 1
2 1
1 2
输出
No
No
Yes
No
No

java代码实现：

package com.example.demo;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Pattern;

/**
 * Created by Administrator on 2019/4/3.
 */
public class Test1 {
    public static void main(String[] args) throws IOException {

        try {
            List<Integer> list = new ArrayList();

            System.out.println("输入多边形的边数：");

            Scanner scan = new Scanner(System.in);
            String text = scan.nextLine();
            //获取输入的n值
            int n = Integer.parseInt(text);

            if (n >= 1 && n <= 50000) {
                Scanner scan1;
                String text1;

                //获取输入 边数的信息
                for (int y = 0; y < n; y++) {
                    scan1 = new Scanner(System.in);
                    text1 = scan1.nextLine();
                    //i 和 L之间用“ "隔开
                    Pattern pattern = Pattern.compile(" ");
                    String[] split = pattern.split(text1);
                    //获取到的信息转换为List<Integer>
                    List<Integer> data = stringArrayParseIntegerArray(split);

                    if (data.size() != 2) {
                        System.out.println("参数形式错误");
                        break;
                    }

                    //i=1 or 2  代表增加还是删除
                    int i;
                    //L  边长
                    int L = data.get(1);
                    if (L >= 1 && L <= 1000000000) {
                        if ((i = data.get(0)) == 1) {
                            list.add(L);
                        } else if (i == 2) {
                            Integer index = null;
                            for (int q = 0; q < list.size(); q++) {
                                if (L == list.get(q)) {
                                    index = q;
                                    break;
                                }
                            }
                            if (index != null) {
                                //此处不能直接list.remove(index); 因为index是个Integer类型的list.remove(object)会去删除list里面的object
                                list.remove((int) index);
                            }
                        } else {
                            System.out.println("参数异常，程序终止");
                            break;
                        }

                        Collections.sort(list);
                        if (list.size() == 1) {
                            System.out.println("no");
                        } else {
                            int sum = 0;
                            for (int t = 0; t < list.size() - 1; t++) {
                                sum += list.get(t);
                            }
                            int max = list.get(list.size() - 1);
                            if (max < sum) {
                                System.out.println("yes");
                            } else {
                                System.out.println("no");
                            }
                        }
                    }

                }
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }


    }

    private static List<Integer> stringArrayParseIntegerArray(String[] split) {
        List<Integer> data = new ArrayList<>();
        for (int j = 0; j < split.length; j++) {
            data.add(Integer.parseInt(split[j]));
        }
        return data;
    }

}