Java面向对象编程

对于IP地址130.63.160.2，MASK为255.255.255.0，子网号为（）

A. 160.2

B. 160

C. 63.160

D. 130.63.160

答案：B

将网络物理地址转换为IP地址的协议是（）

A. IP

B. ICMP

C. ARP

D. RARP

答案：D

有关cookie和session的描述，下面错误的是（）

A. cookie数据存放在客户的浏览器上，session数据放在服务器上

B. session是针对每一个用户的，变量的值保存在服务器上，用一个sessionID来区分是哪个用户session变量

C. 保存这个session id的方式可以采用cookie

D. 只要关闭浏览器，session就消失了

答案：D

关于TIME_WAIT状态的描述，下面说法错误的是（）

A. TIME_WAIT出现在被动关闭一方，CLOSE_WAIT出现在主动关闭一方

B. 从TIME_WAIT状态到CLOSED状态，有一个超时设置，这个超时设置是 2*MSL

C. TIME_WAIT确保有足够的时间让对端收到了ACK，如果被动关闭的那方没有收到Ack，就会触发被动端重发Fin，一来一去正好2个MSL

D. 有足够的时间让这个连接不会跟后面的连接混在一起

答案：A

TCP连接释放过程，叙述不正确的是（）

A. 通过设置FIN为来表示释放连接

B. 当一方释放连接后另一方即不能继续发送数据

C. 只有双方均释放连接后，该连接才被释放

D. 释放连接采用四次挥手机制

答案：B

下面有关TCP协议的描述，说法错误的是（）

A. TCP使用窗口机制进行流量控制

B. 由于TCP连接是全双工的，因此每个方向都必须单独进行关闭，需要四次握手

C. TCP连接建立需要三次握手

D. 被动关闭socket后，会进入到TIME_WAIT状态

答案：D

查看TCP连接的命令是什么（）

A. tcpdump

B. top

C. netstat

D. ifconfig

答案：C

某IP地址192.168.48.10，掩码为255.255.255.128，其所在的子网为（），广播地址为（），有效的主机IP地址范围是（）

A. 192.168.48.0/192.168.48.127/192.168.48.1 到 192.168.48.126

B. 192.168.48.0/192.168.48.255/192.168.48.1 到 192.168.48.255

C. 192.168.48.1/192.168.48.255/192.168.48.1 到 192.168.48.126

D. 192.168.48.1/192.168.48.127/192.168.48.1 到 192.168.48.255

答案：A

172.16.100.5/255.255.255.252 的网络地址和主机号是多少（）

A. 172.16.100.4 1

B. 172.16.100.4 5

C. 172.16.100.5 1

D. 172.16.100.5 5

答案：A

下面有关NAT的描述，说法错误的是（）

A. NAT是一种把内部私有网络地址（IP地址）翻译成合法网络IP地址的技术

B. NAT的实现方式有三种，即静态转换Static Nat、动态转换Dynamic Nat和端口多路复用OverLoad

C. NAT可以有效的缓解了IP地址不足的问题

D. 虚拟机里配置NAT模式，需要手工为虚拟系统配置IP地址、子网掩码，而且还要和宿主机器处于同一网段

答案：D

合唱团

题目描述：有 n 个学生站成一排，每个学生有一个能力值，牛牛想从这 n 个学生中按照顺序选取 k 名学生，要求相邻两个学生的位置编号的差不超过 d，使得这 k 个学生 的能力值的乘积最大，你能返回最大的乘积吗？ 

输入描述：每个输入包含 1 个测试用例。每个测试数据的第一行包含一个整数 n (1 <= n <= 50)，表示学生的个数，接下来的一行，包含 n 个整数，按顺序表示每个学生 的能力值 a （-50 <= ai <= 50）。接下来的一行包含两个整数，k 和 d (1 <= k <= 10, 1 <= d <= 50)。 

输出描述：输出一行表示最大的乘积。

 

public class Main77 {

    //合唱团

    public static long getMax(int[] arr, int n, int k, int d) {

        long[][] maxValue = new long[n + 1][k + 1];

        long[][] minValue = new long[n + 1][k + 1];

        long ret = 0;

        //F(i,j):以第i个学生结尾，共选了j个同学的最大值

        //初始状态F(i,1):arr[i]

        for (int i = 1; i <= n; ++i) {

            maxValue[i][1] = minValue[i][1] = arr[i - 1];

        }

        for (int i = 1; i <= n; ++i) {

            for (int j = 1; j <= k; ++j) {

                //约束条件：相邻同学间隔不超过d

                for (int m = i - 1; m >= Math.max(i - d, 1) ; --m) {

                    maxValue[i][j] = Math.max(maxValue[i][j],

                            Math.max(maxValue[m][j - 1] * arr[i - 1],

                                    minValue[m][j - 1] * arr[i - 1]));



                    minValue[i][j] = Math.min(minValue[i][j],

                            Math.min(maxValue[m][j - 1] * arr[i - 1],

                                    minValue[m][j - 1] * arr[i - 1]));

                }

            }

            //更新最大值max(F(i,k))

            ret = Math.max(ret, maxValue[i][k]);

        }

        return ret;

    }



    public static void main(String[] args) {

        int n;

        int k;

        int d;

        Scanner scanner = new Scanner(System.in);

        n = scanner.nextInt();

        int[] arr = new int[n];

        for (int i = 0; i < n; ++i) {

            arr[i] = scanner.nextInt();

        }

        k = scanner.nextInt();

        d = scanner.nextInt();

        System.out.println(getMax(arr, n, k, d));

    }

}

马戏团

题目描述：搜狐员工小王最近利用假期在外地旅游，在某个小镇碰到一个马戏团表演，精彩的表演结束后发现团长正和大伙在帐篷前激烈讨论，小王打听了下了解到， 马戏 团正打算出一个新节目“最高罗汉塔”，即马戏团员叠罗汉表演。考虑到安全因素，要求叠罗汉过程中，站在某个人肩上的人应该既比自己矮又比自己瘦，或相 等。 团长想要本次节目中的罗汉塔叠的最高，由于人数众多，正在头疼如何安排人员的问题。小王觉得这个问题很简单，于是统计了参与最高罗汉塔表演的所有 团员的身高体重，并且很快找到叠最高罗汉塔的人员序列。 现在你手上也拿到了这样一份身高体重表，请找出可以叠出的最高罗汉塔的高度，这份表中马戏团员 依次编号为1到N。 

输入描述：首先一个正整数N，表示人员个数。 之后N行，每行三个数，分别对应马戏团员编号，体重和身高。 

输出描述：正整数m，表示罗汉塔的高度。

class node implements Comparable<node>{

    int w;

    int h;

    public node(int w,int h){

        this.w=w;

        this.h=h;

    }



    @Override

    public int compareTo(node obj) {

        int ret=w-obj.w;

        //体重相同，身高降序

        if (ret==0){

            return obj.h-h;

        }

        return ret;

    }

}



public class Main78 {



    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);

        while (scanner.hasNextInt()){

            int n= scanner.nextInt();

            node[] arr=new node[n];

            for (int i = 0; i < n; ++i) {

                scanner.nextInt();

                arr[i]=new node(scanner.nextInt(), scanner.nextInt());

            }

            System.out.println(getMaxLength(arr,n));

        }

    }



    public static int getMaxLength(node[] arr,int n){

        //排序

        Arrays.sort(arr);

        //计算最大子序列长度

        int ret=0;

        //F(i)：以第i个元素结尾的最大子序列长度

        //初始值：F(i)=1

        int[] maxLength=new int[n];

        for (int i = 0; i < n; ++i) {

            maxLength[i]=1;

        }

        for (int i = 1; i < n; ++i) {

            for (int j = 0; j < i; ++j) {

                if (arr[j].h <=arr[i].h){

                    maxLength[i]=Math.max(maxLength[i],maxLength[j]+1);

                }

            }

            //跟新最值max(F(i))

            ret=Math.max(ret,maxLength[i]);

        }

        return ret;

    }

}