机考[91 - 100]

091 【迷宫问题】[图-dfs]

定义一个二维数组 N*M ，如 5 × 5 数组下所示：
int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的路线。入口点为[0,0],既第一格是可以走的路。
数据范围： 2≤n,m≤10 ， 输入的内容只包含 0≤val≤1
输入描述：
输入两个整数，分别表示二维数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。
输出描述：
左上角到右下角的最短路径，格式如样例所示。
示例1
输入：
5 5
0 1 0 0 0
0 1 1 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
输出：
(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)
示例2
输入：
5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 1
0 1 1 1 0
0 0 0 0 0
输出：
(0,0)
(1,0)
(2,0)
(3,0)
(4,0)
(4,1)
(4,2)
(4,3)
(4,4)
说明：注意：不能斜着走！！

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

/**
 * DFS找最短路线
 int maze[5][5] = {
0,1,0,0,0
0,1,1,1,0
0,0,0,0,0
0,1,1,1,0
0,0,0,1,0
 };
 */
public class Main {
    private static int n1;
    private static int m1;
    private static int[][] arr;//邻接表
    private static boolean[][] mark;
    private static int endX1;
    private static int endY1;
    private static List<Point> list = new ArrayList<>();
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] sa = sc.nextLine().split(" ");
        n1 = Integer.parseInt(sa[0]);
        m1 = Integer.parseInt(sa[1]);
        endX1 = n1 -1;
        endY1 = m1 -1;
        arr = new int[n1][m1];
        mark = new boolean[n1][m1];
        for (int i = 0; i < n1; i++) {
            String[] split = sc.nextLine().split(" ");
            for (int j = 0; j < m1; j++) {
                arr[i][j] = Integer.parseInt(split[j]);
            }
        }
        dfs(0, 0, 0);
        Collections.reverse(list);
        for (int i = 0; i < list.size(); i++) {
            Point point = list.get(i);
            System.out.println("(" + point.x1 + "," +point.y1+ ")");
        }
    }

    //dfs就是递归求最小值
    private static boolean dfs(int x1,int y1,int step){
        if (x1 == endX1 && y1 == endY1){
            list.add(new Point(endX1,endY1));
            return true;
        }
        int[][] next = {{1,0},{0,1},{0,-1},{-1,0}};
        boolean flag = false;
        for (int i = 0; i < 4; i++) {
            int nextX = x1 + next[i][0];
            int nextY = y1 + next[i][1];
            if (nextX < 0 || nextX >= n1 || nextY<0 || nextY>= m1){
                continue;
            }
            if (arr[nextX][nextY] == 0 && !mark[nextX][nextY]){//下个点是0 且未做标记
                mark[nextX][nextY] = true;
                if (dfs(nextX, nextY, step + 1)) {
                    flag = true;
                    list.add(new Point(x1,y1));
                }
                mark[nextX][nextY] = false;
            }
        }
        return flag;
    }
    static class Point{
        int x1;
        int y1;

        public Point(int x1, int y1) {
            this.x1 = x1;
            this.y1 = y1;
        }
    }
}

092 【机器人走迷宫】[图-dfs]

1、 房间由XY的方格组成，例如下图为64的大小。每一个方格以坐标(x，y)描述。
2、 机器人固定从方格(0，0)出发，只能向东或者向北前进。出口固定为房间的最东北角，如下图的方格(5，3)。用例保证机器人可以从入口走到出口。
3、 房间有些方格是墙壁，如(4，1)，机器人不能经过那儿。
4、 有些地方是一旦到达就无法走到出口的，如标记为B的方格，称之为陷阱方格。
5、 有些地方是机器人无法到达的的，如标记为A的方格，称之为不可达方格，不可达方格不包括墙壁所在的位置。
6、 如下示例图中，陷阱方格有2个，不可达方格有3个。
7、 请为该机器人实现路径规划功能：给定房间大小、墙壁位置，请计算出陷阱方格与不可达方格分别有多少个。

/**
 * 机器人走迷宫
 * BFS解决在不在一起的问题
 * DFS解决路径问题
 */
public class ZT92 {
    private static int n1;
    private static int m1;
    private static int endX1;
    private static int endY1;
    private static int[][] arr;
    private static boolean[][] mark;
    private static int trip =0;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] nms = sc.nextLine().split(" ");
        n1 = Integer.parseInt(nms[1]);
        m1 = Integer.parseInt(nms[0]);
        arr = new int[n1][m1];
        mark = new boolean[n1][m1];
        int x1 = n1 - 1;
        int y1 = 0;
        endX1 = 0;
        endY1 = m1 - 1;
        int wellCount = Integer.parseInt(sc.nextLine());
        for (int i = 0; i < wellCount; i++) {
            String[] wall = sc.nextLine().split(" ");
            int weX1 = n1 -1 - Integer.parseInt(wall[1]);
            int weY1 = Integer.parseInt(wall[0]);
            arr[weX1][weY1] = 1;
        }
        arr[x1][y1] = 2;//初始化点位
        dfs(x1, y1);
        //遍历所有坐标 结果是0的就是A
        int unReach = 0;
        for (int i = 0; i < n1; i++) {
            for (int j = 0; j < m1; j++) {
                if (arr[i][j] == 0){
                    unReach++;
                    System.out.println(i + ":" + j);
                }
            }
        }
        System.out.println(trip + " " + unReach);
    }

    private static boolean dfs(int x1,int y1){
        boolean flag = false;
        if (x1 == endX1 && y1 == endY1){
            return true;
        }
        int[][] next = {{-1,0},{0,1}};
        int nextX1 = 0;
        int nextY1 = 0;
        for (int i = 0; i < 2; i++) {
            nextX1 = x1 + next[i][0];
            nextY1 = y1 + next[i][1];
            if (nextX1 < 0 || nextY1 >=m1 ){
                continue;
            }
            if (arr[nextX1][nextY1] != 1 && !mark[nextX1][nextY1]){
                mark[nextX1][nextY1] = true;
                arr[nextX1][nextY1] = 2;//为了区别出未曾经过的坐标A
                boolean dfs = dfs(nextX1, nextY1);
                if (flag || dfs){
                    flag = true;
                }
                mark[nextX1][nextY1] = false;
            }
        }
        if (!flag){//坐标点B
            trip++;
            System.out.println(x1 + ":" + y1);
        }
        return flag;
    }
}

093 【最长广播响应】(图-迪杰斯特拉算法)

某通信网络中有N个网络结点，用1到N进行标识。网络中的结点互联互通，且结点之间的消息传递有时延，相连结点的时延均为一个时间单位。
现给定网络结点的连接关系link[i]={u,v}，其中u和v表示网络结点。
当指定一个结点向其他结点进行广播，所有被广播结点收到消息后都会在原路径上回复一条响应消息，请计算发送结点至少需要等待几个时间单位才能收到所有被广播结点的响应消息。
注：
1、N的取值范围为[1,100]；
2、连接关系link的长度不超过3000，且1 <= u,v <= N；
3、网络中任意结点间均是可达的；
输入描述:
输入的第一行为两个正整数，分别表示网络结点的个数N，以及时延列表的长度I；
接下来的I行输入，表示结点间的连接关系列表；
最后一行的输入为一个正整数，表示指定的广播结点序号；
输出描述:
输出一个整数，表示发送结点接收到所有响应消息至少需要等待的时长。
示例1
输入
5 7
2 1
1 4
2 4
2 3
3 4
3 5
4 5
2
输出
4
说明
2到5的最小时延是2个时间单位，而2到其他结点的最小时延是1个时间单位，所以2收到所有结点的最大响应时间为2*2=4。

public class ZT91Djtls {
    private static int[][] arr;//邻接表
    private static int[] dis;//表示从某个点到其他点位的最小距离
    private static boolean[] mark;
    private static int from;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] nms = sc.nextLine().split(" ");
        int count = Integer.parseInt(nms[0]);
        int line = Integer.parseInt(nms[1]);
        arr = new int[count+1][count+1];
        for (int i = 0; i < line; i++) {
            String[] dis = sc.nextLine().split(" ");
            int x1 = Integer.parseInt(dis[0]);
            int y1 = Integer.parseInt(dis[1]);
            arr[x1][y1] = 1;
        }
        from = Integer.parseInt(sc.nextLine());//从哪个点开始广播
        dis = new int[count+1];
        for (int i = 0; i <= count; i++) {
            if (i == from){
                dis[i] = 0;
            }else {
                dis[i] = Integer.MAX_VALUE;
            }
        }
        mark = new boolean[count+1];
        calcTls(from,count);
    }

    private static void calcTls(int local,int count){
        //广播的点初始化距离
        mark[local] = true;
        for (int i = 1; i <= count; i++) {
            if (arr[local][i] != 0){
                dis[i] = arr[local][i];
            }
        }

        int used = 0;
        while (used< count){
            //计算下一个加入进来的坐标
            int tempLocal = 0;
            int distMin = Integer.MAX_VALUE;
            for (int i = 1; i <= count; i++) {
                //距离最近的点先加进来
                if (!mark[i] && dis[i] < distMin){
                    distMin = dis[i];
                    tempLocal = i;
                }
            }
            local = tempLocal;

            //逐个点的加入到图中
            mark[local] = true;
            for (int i = 1; i <= count; i++) {
                if (arr[local][i] != 0){
                    dis[i] = Math.min(dis[local] + arr[local][i],dis[i]);
                }
            }
            used++;
        }
        int maxDis = Integer.MIN_VALUE;
        for (int i = 1; i <= count; i++) {
            System.out.println(from + "到" + i + "的距离" + dis[i]);
            maxDis = Math.max(maxDis,dis[i]);
        }
        System.out.println(maxDis * 2);//时间要花双倍
    }
}

094 【求满足条件的最长子串的长度】

给定一个字符串，只包含字母和数字，按要求找出字符串中的最长（连续）子串的长度，字符串本身是其最长的子串，子串要求：
1、 只包含1个字母(a~z, A~Z)，其余必须是数字；
2、 字母可以在子串中的任意位置；
如果找不到满足要求的子串，如全是字母或全是数字，则返回-1。
输入描述：字符串(只包含字母和数字)
输出描述：子串的长度
示例1
输入
abC124ACb
输出
4
说明
满足条件的最长子串是C124或者124A，长度都是4
示例2
输入
a5
输出
2
说明
字符串自身就是满足条件的子串，长度为2
示例3
输入
aBB9
输出
2
说明
满足条件的子串为B9，长度为2
示例4
输入
abcdef
输出
-1
说明
没有满足要求的子串，返回-1

public class ZT94 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();

        //双指针滑动
        int left = 0;
        int right = 1;
        int maxLe = -1;
        while (left < input.length() && right < input.length()){
            right++;
            String str = input.substring(left,right);//左取右不取
            if (checkStr(str)){
                maxLe = Math.max(str.length(),maxLe);
            }else {
                left++;
            }
        }
        System.out.println(maxLe);
    }

    private static boolean checkStr(String str){
        char[] chars = str.toCharArray();
        int wordCount = 0;
        int numCount = 0;
        for (int i = 0; i < chars.length; i++) {
            if ((chars[i] >= 'a' && chars[i] <= 'z') || (chars[i] >= 'A' && chars[i] <= 'Z')){
                if (++wordCount >= 2){
                    return false;
                }
            }else {
                numCount++;
            }
        }
        return numCount > 0 && wordCount > 0;
    }
}

095 【We Are A Team】

总共有n个人在机房，每个人有一个标号（1 <= 标号 <=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：
1、消息构成为：a b c，整数a、b分别代表了两个人的标号，整数c代表指令。
2、c0代表a和b在一个团队内。
3、c1代表需要判定a和b的关系，如果a和b是一个团队，输出一行“we are a team”，如果不是，输出一行“we are not a team”。
4、c为其它值，或当前行a或b超出1~n的范围，输出“da pian zi”。
输入描述:
1、第一行包含两个整数n, m(1 <= n, m <= 100000)，分别表示有n个人和m条消息。
2、随后的m行，每行一条消息，消息格式为:a b c (1 <= a, b <= n, 0 <= c <= 1)。
输出描述:
1、c==1时，根据a和b是否在一个团队中输出一行字符串，在一个团队中输出“we are a team”，不在一个团队中输出“we are not a team”。
2、c为其他值，或当前行a或b的标号小于1或者大于n时，输出字符串“da pian zi”。
3、如果第一行n和m的值超出约定的范围时，输出字符串"NULL"。
示例1
输入
5 6
1 2 0
1 2 1
1 5 0
2 3 1
2 5 1
1 3 2
输出
we are a team
we are not a team
we are a team
da pian zi
说明
第2行定义了1和2是一个团队
第3行要求进行判定，输出"we are a team"
第4行定义了1和5是一个团队，自然2和5也是一个团队
第5行要求进行判定，输出"we are not a team"
第6行要求进行判定，输出"we are a team"
第7行c为其它值，输出"da pian zi"

public class ZT95 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] nms = sc.nextLine().split(" ");
        int nums = Integer.parseInt(nms[0]);
        int mes = Integer.parseInt(nms[1]);
        List<Set<Integer>> lists = new ArrayList<>();
        List<String> waitForVerify = new ArrayList<>();
        for (int i = 0; i < mes; i++) {
            String real = sc.nextLine();
            String[] rels = real.split(" ");
            int i1 = Integer.parseInt(rels[0]);
            int i2 = Integer.parseInt(rels[1]);
            int i3 = Integer.parseInt(rels[2]);
            if (i3 != 0){
                waitForVerify.add(real);
            }else {
                boolean flag = false;
                for (int j = 0; j < lists.size(); j++) {
                    Set<Integer> set = lists.get(j);
                    if (set.contains(i1) || set.contains(i2)){
                        set.add(i1);
                        set.add(i2);
                        flag = true;
                        break;
                    }
                }
                if (!flag){
                    Set<Integer> set = new HashSet<>();
                    set.add(i1);
                    set.add(i2);
                    lists.add(set);
                }
            }
        }
        //判断非0的关系
        for (int i = 0; i < waitForVerify.size(); i++) {
            String[] reli = waitForVerify.get(i).split(" ");
            int i1 = Integer.parseInt(reli[0]);
            int i2 = Integer.parseInt(reli[1]);
            int i3 = Integer.parseInt(reli[2]);
            if (i3 != 1){
                System.out.println("da pian zi");
                continue;
            }
            for (int j = 0; j < lists.size(); j++) {
                Set<Integer> set = lists.get(j);
                if (set.contains(i1) && set.contains(i2)){
                    System.out.println("we are a team");
                }else {
                    System.out.println("we are not a team");
                }
            }
        }
    }
}

096 【招聘】

某公司组织一场公开招聘活动，假设由于人数和场地的限制，每人每次面试的时长不等，并已经安排给定，用(S1,E1)、(S2,E2)、(Sj,Ej)…(Si < Ei，均为非负整数)表示每场面试的开始和结束时间。面试采用一对一的方式，即一名面试官同时只能面试一名应试者，一名面试官完成一次面试后可以立即进行下一场面试，且每个面试官的面试人次不超过m。
为了支撑招聘活动高效顺利进行，请你计算至少需要多少名面试官。
输入描述:
输入的第一行为面试官的最多面试人次m，第二行为当天总的面试场次n，接下来的n行为每场面试的起始时间和结束时间，起始时间和结束时间用空格分隔。
其中，1 <= n, m <= 500
输出描述:
输出一个整数，表示至少需要的面试官数量。
示例1
输入
2
5
1 2
2 3
3 4
4 5
5 6
输出
3
说明
总共有5场面试，且面试时间都不重叠，但每个面试官最多只能面试2人次，所以需要3名面试官。
示例2
输入
3
3
1 2
2 3
3 4
输出
1
说明
总共有3场面试，面试时间都不重叠，每个面试官最多能面试3人次，所以只需要1名面试官。
示例3
输入
3
3
8 35
5 10
1 3
输出
2
说明
总共有3场面试，[5,10]和[8,35]有重叠，所以至少需要2名面试官。

097 【乱序整数序列两数之和绝对值最小】

给定一个随机的整数（可能存在正整数和负整数）数组 nums ，请你在该数组中找出两个数，其和的绝对值(|nums[x]+nums[y]|)为最小值，并返回这个两个数（按从小到大返回）以及绝对值。
每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
输入描述:
一个通过空格分割的有序整数序列字符串，最多1000个整数，且整数数值范围是 [-65535, 65535]。
输出描述:
两数之和绝对值最小值
示例1
输入
-1 -3 7 5 11 15
输出
-3 5 2
说明
因为 |nums[0] + nums[2]| = |-3 + 5| = 2 最小，所以返回 -3 5 2

public class ZT97 {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        String[] nums = sc.nextLine().split(" ");
        int[] arr = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            arr[i] = Integer.parseInt(nums[i]);
        }
        int res = Integer.MAX_VALUE;
        int l1 = Integer.MIN_VALUE;
        int l2 = Integer.MIN_VALUE;
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j < nums.length; j++) {
                int temp = Math.abs(arr[i] + arr[j]);
                if (temp < res){
                    l1 = arr[i];
                    l2 = arr[j];
                    res = temp;
                }
            }
        }
        if (l1>l2){
            int temp = l2;
            l2 = l1;
            l1 = temp;
        }
        System.out.println(l1 +" " + l2 + " " + res);
    }
}

098 【电信号】

输入一串方波信号，求取最长的完全连续交替方波信号，并将其输出，如果有相同长度的交替方波信号，输出任一即可，方波信号高位用1标识，低位用0标识，如图：

说明：
1） 一个完整的信号一定以0开始然后以0结尾，即010是一个完整信号，但101，1010，0101不是
2）输入的一串方波信号是由一个或多个完整信号组成
3） 两个相邻信号之间可能有0个或多个低位，如0110010，011000010
4） 同一个信号中可以有连续的高位，如01110101011110001010，前14位是一个具有连续高位的信号
5） 完全连续交替方波是指10交替，如01010是完全连续交替方波，0110不是
输入描述:
输入信号字符串（长度>=3且<=1024）：
0010101010110000101000010
注：输入总是合法的，不用考虑异常情况
输出描述:
输出最长的完全连续交替方波信号串：
01010
若不存在完全连续交替方波信号串，输出 -1
示例1
输入
00101010101100001010010
输出
01010
备注:
输入信号串中有三个信号：0 010101010110(第一个信号段) 00 01010(第二个信号段) 010(第三个信号段)
第一个信号虽然有交替的方波信号段，但出现了11部分的连续高位，不算完全连续交替方波，在剩下的连续方波信号串中01010最长

public class ZT98 {
    private static int maxLength = Integer.MIN_VALUE;
    private static String res;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String input = sc.nextLine();
        if (input.contains("00")) {//包含2各及以上的信号波
            String[] split = input.split("00");
            //0和尾要在后面和前面各添加一个0
            //其他的前后均要补0
            for (int i = 0; i < split.length; i++) {
                String temp = split[i];
                if (i == 0){
                    check(temp + "0");
                }else if (i == split.length -1){
                    check("0"+temp);
                }else {
                    check("0" + temp + "0");
                }
            }
        }else {//单信号波 01010
            check(input);
        }
        if (maxLength == Integer.MIN_VALUE){
            System.out.println(-1);
        }else {
            System.out.println(res);
        }
    }
    private static void check(String str){//首位一定是以0开头的 00 /01
        char[] chars = str.toCharArray();
        boolean start = false;
        int startIdx = 0;
        int endIdx = -1;
        char pre = '1';
        for (int i = 0; i < chars.length; i++) {
            if (!start && i+1 < chars.length && chars[i] == '0' && chars[i+1] == '1'){
                start = true;
                startIdx = i;
                pre = '0';
                continue;
            }
            if (pre != chars[i]){
                pre = chars[i];
            }else if (pre =='1' && chars[i] == '1'){
                return;
            } else {
                endIdx = i;
                break;
            }
        }
        if (endIdx == -1){
            if (str.length() - startIdx > maxLength){
                maxLength = str.length() - startIdx;
                res = str.substring(startIdx);
            }
        }else {
            if (endIdx - startIdx > maxLength){
                maxLength = endIdx - startIdx;
                res = str.substring(startIdx,endIdx);
            }
        }
    }
}

099 【任务最优调度】

给定一个正整型数组表示待系统执行的任务列表，数组的每一个元素代表一个任务，元素的值表示该任务的类型。请计算执行完所有任务所需的最短时间。任务执行规则如下：
1、任务可以按任意顺序执行，且每个任务执行耗时间均为1个时间单位。
2、两个同类型的任务之间必须有长度为N个单位的冷却时间，比如：N为2时，在时间K执行了类型3的任务，那么K+1和K+2两个时间不能执行类型3任务。
3、系统在任何一个单位时间内都可以执行一个任务，或者等待状态。
说明：数组最大长度为1000,数组最大值1000.
输入描述:
第一行记录一个用半角逗号分隔的数组，数组长度不超过1000，数组元素的值不超过1000
第二行记录任务冷却时间，N为正整数，N<=100。
输出描述:
输出为执行完所有任务所需的最短时间。
示例1
输入
2,2,2,3
2
输出
7
说明
时间1：执行类型2任务。
时间2：执行类型3的任务（因为冷却时间为2，所以时间2不能执行类型2的任务）。
时间3：系统等待（仍然在类型2的冷却时间）。
时间4：执行类型2任务。
时间5：系统等待。
时间6：系统等待。
时间7：执行类型2任务。
因此总共耗时7。

100 【猜密码】

小杨申请了一个保密柜，但是他忘记了密码。只记得密码都是数字，而且所有数字都是不重复的。请你根据他记住的数字范围和密码的最小数字数量，帮他算下有哪些可能的组合，规则如下：
1、输出的组合都是从可选的数字范围中选取的，且不能重复；
2、输出的密码数字要按照从小到大的顺序排列，密码组合需要按照字母顺序，从小到大的顺序排序。
3、输出的每一个组合的数字的数量要大于等于密码最小数字数量；
4、如果可能的组合为空，则返回“None”
输入描述:
1、输入的第一行是可能的密码数字列表，数字间以半角逗号分隔
2、输入的第二行是密码最小数字数量
输出描述:
可能的密码组合，每种组合显示成一行，每个组合内部的数字以半角逗号分隔，从小到大的顺序排列。
输出的组合间需要按照字典序排序。
比如：
2,3,4放到2,4的前面
示例1
输入
2,3,4
2
输出
2,3
2,3,4
2,4
3,4
说明
最小密码数量是两个，可能有三种组合：
2,3
2,4
3,4
三个密码有一种：
2,3,4
示例2
输入
2,0
1
输出
0
0,2
2
说明
可能的密码组合，一个的有两种 ：
0
2
两个的有一个：
0,2
备注:
字典序是指按照单词出现在字典的顺序进行排序的方法，比如：
a排在b前
a排在ab前
ab排在ac前
ac排在aca前

在这里插入代码片

101 【分积木】

Solo和koko是两兄弟，妈妈给了他们一大堆积木，每块积木上都有自己的重量。现在他们想要将这些积木分成两堆。哥哥Solo负责分配，弟弟koko要求两个人获得的积木总重量“相等”（根据Koko的逻辑），个数可以不同，不然就会哭，但koko只会先将两个数转成二进制再进行加法，而且总会忘记进位（每个进位都忘记）。如当25（11101）加11（1011）时，koko得到的计算结果是18（10010）：
11001
+01011--------
10010
Solo想要尽可能使自己得到的积木总重量最大，且不让koko哭。
输入描述:
3
3 5 6
第一行是一个整数N(2≤N≤100)，表示有多少块积木；第二行为空格分开的N个整数Ci(1≤Ci≤106)，表示第i块积木的重量。
输出描述:
11
让koko不哭，输出Solo所能获得积木的最大总重量；否则输出“NO”。
示例1
输入
3
3 5 6
输出
11
备注:
如果能让koko不哭，输出Solo所能获得的积木的总重量，否则输出-1。
该样例输出为11。
解释：Solo能获得重量为5和6的两块积木，5转成二级制为101，6转成二进制位110，按照koko的计算方法（忘记进位），结果为11(二进制)。Koko获得重量为3的积木，转成二进制位11(二进制)。Solo和koko得到的积木的重量都是11(二进制)。因此Solo可以获得的积木的总重量是5+6=11（十进制）。

在这里插入代码片