ccf url映射基于JAVA实现（100分）

试题编号：	201709-2
试题名称：	公共钥匙盒
时间限制：	1.0s
内存限制：	256.0MB
问题描述：	问题描述　　有一个学校的老师共用 N个教室，按照规定，所有的钥匙都必须放在公共钥匙盒里，老师不能带钥匙回家。每次老师上课前，都从公共钥匙盒里找到自己上课的教室的钥匙去开门，上完课后，再将钥匙放回到钥匙盒中。　　钥匙盒一共有 N个挂钩，从左到右排成一排，用来挂 N个教室的钥匙。一串钥匙没有固定的悬挂位置，但钥匙上有标识，所以老师们不会弄混钥匙。　　每次取钥匙的时候，老师们都会找到自己所需要的钥匙将其取走，而不会移动其他钥匙。每次还钥匙的时候，还钥匙的老师会找到最左边的空的挂钩，将钥匙挂在这个挂钩上。如果有多位老师还钥匙，则他们按钥匙编号从小到大的顺序还。如果同一时刻既有老师还钥匙又有老师取钥匙，则老师们会先将钥匙全还回去再取出。　　今天开始的时候钥匙是按编号从小到大的顺序放在钥匙盒里的。有 K位老师要上课，给出每位老师所需要的钥匙、开始上课的时间和上课的时长，假设下课时间就是还钥匙时间，请问最终钥匙盒里面钥匙的顺序是怎样的？输入格式　　输入的第一行包含两个整数 N, K。　　接下来 K行，每行三个整数 w, s, c，分别表示一位老师要使用的钥匙编号、开始上课的时间和上课的时长。可能有多位老师使用同一把钥匙，但是老师使用钥匙的时间不会重叠。　　保证输入数据满足输入格式，你不用检查数据合法性。输出格式　　输出一行，包含 N个整数，相邻整数间用一个空格分隔，依次表示每个挂钩上挂的钥匙编号。样例输入 5 2 4 3 3 2 2 7 样例输出 1 4 3 2 5 样例说明　　第一位老师从时刻3开始使用4号教室的钥匙，使用3单位时间，所以在时刻6还钥匙。第二位老师从时刻2开始使用钥匙，使用7单位时间，所以在时刻9还钥匙。　　每个关键时刻后的钥匙状态如下（X表示空）：　　时刻2后为1X345；　　时刻3后为1X3X5；　　时刻6后为143X5；　　时刻9后为14325。样例输入 5 7 1 1 14 3 3 12 1 15 12 2 7 20 3 18 12 4 21 19 5 30 9 样例输出 1 2 3 5 4 评测用例规模与约定　　对于30%的评测用例，1 ≤ N, K ≤ 10, 1 ≤ w ≤ N, 1 ≤ s, c ≤ 30；　　对于60%的评测用例，1 ≤ N, K ≤ 50，1 ≤ w ≤ N，1 ≤ s ≤ 300，1 ≤ c ≤ 50；　　对于所有评测用例，1 ≤ N, K ≤ 1000，1 ≤ w ≤ N，1 ≤ s ≤ 10000，1 ≤ c ≤ 100。

这题目略坑，做到现在最高70分，如果有谁能看出我的问题的话，希望可以在评论里说下。

一开始我是想把每行字符串按/拆分，然后存进一个Stirng[]数组里，利用正则表达式去匹配规则的Int，str,path,然而他给我报了一个运行错误，拿了30分。后来参考了下c++拿满分的代码，改成了一个个字符匹配，结果70分，还是给我报运行错误，实在不知道是什么原因了。

----------

2018/6/22 满分了。虽然还是不懂为啥满分了。

下面30分的代码：

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class url {
    static List<Rule> list=new ArrayList<>();
    static int flag;
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String line=in.nextLine();
        String[] linetemp=blankSplit(line);
        int n=Integer.parseInt(linetemp[0]); //读取规则数量
        int m=Integer.parseInt(linetemp[1]); //读取地址数量
        for (int i=0;i<n;i++){ //将规则存入静态数组list中
            String line2=in.nextLine();
            String[] tempstr=blankSplit(line2);
            String rule=tempstr[0];
            String name=tempstr[1];
            Rule rule1=new Rule(rule,name);
            list.add(rule1);
        }
        for (int j=0;j<m;j++){ //一条条读地址，判断是否符合规则
            String temp=in.nextLine(); //获取地址
            String[] words=strSplit(temp); //截取字符串，将地址拆分成数组
            for (int i=0;i<list.size();i++){
                String rule=list.get(i).rule;
                String[] rules=strSplit(rule);//将规则拆分成数组
                if (rules.length>words.length){
                    continue;
                }
                List<String> mathes=new ArrayList<>();
                int count=0;
                for (int k = 0,p=0;p<words.length; p++) {
                    if (k>=rules.length){ //如果规则字符串数组已到尽头了，则不一直保持最后一个
                        break;
                    }
                    if (rules[k].equals(words[p])) { //如果两个字符串相等，则往后继续匹配
                        count++;
                        k++;
                    } else {
                        String temp3 = rules[k]; //如果不等，先将规则里面的字符串取出来
                        if (isContainSign(temp3)) { //如果包含<>,则取出<>里面的内容
                            temp3 = temp3.substring(temp3.indexOf("<") + 1, temp3.indexOf(">"));
                            switch (temp3) { //判断下里面各自是什么
                                case "int": {
                                    String temp4 = words[p];
                                    if (temp4.matches("^[0-9]+$")) {
                                        if (temp4.charAt(0)=='0'){
                                            String newtemp=temp4.substring(1,temp4.length());
                                            mathes.add(newtemp);
                                        }else {
                                            mathes.add(temp4);
                                        }
                                        count++;
                                        k++;
                                    }
                                    else {
                                        p=words.length-1;
                                    }
                                    break;
                                }
                                case "str": {
                                    String temp4 = words[p];
                                    if (temp4.matches("^[a-zA-Z0-9_.\\-]+$")) {
                                        mathes.add(temp4);
                                        count++;
                                        k++;
                                    } else {
                                        p=words.length-1;
                                    }
                                    break;
                                }
                                case "path": {
                                    StringBuilder s=new StringBuilder();
                                    for (;p<words.length;p++){
                                        if (p==words.length-1){
                                            s.append(words[p]);
                                        }else {
                                            s.append(words[p]).append("/");
                                        }
                                    }
                                    String temp4=s.toString();
                                    if (temp4.matches("^[a-zA-Z0-9/_.\\-]+$")) {
                                        mathes.add(temp4);
                                        count=words.length;
                                    }else {
                                        p=words.length-1;
                                    }
                                    break;
                                }
                                default:p=words.length-1;
                                 break;
                            }
                        }
                    }

                }
                if (count==words.length){
                    System.out.print(list.get(i).name+" ");
                    for (String mathe : mathes) {
                        System.out.print(mathe + " ");
                    }
                    System.out.print("\n");
                    flag=1;
                    break;
                }
            }
            if (flag==1){
                flag=0;
            }else {
                System.out.println(404);
            }
        }

    }
    static class Rule{
        String rule;
        String name;

        public Rule(String rule, String name) {
            this.rule = rule;
            this.name = name;
        }
    }

    private static String[] strSplit(String temp) {
        String[] words=temp.split("/");
        if (words.length==0){
           return words;
        }
        String[] ss = new String[words.length-1];
        System.arraycopy(words, 1, ss, 0, ss.length);
        return ss;
    }
    private static String[] blankSplit(String temp){
        String[] words=temp.split(" ");
        return words;
    }
    public static boolean isContainSign(String temp){
        String regx="<[^>]+>";
        Pattern p = Pattern.compile(regx);
        Matcher m = p.matcher(temp);
        return m.find();
    }
}

下面是70分的代码：

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

/**
 * @author yb
 */
public class Url2
{
    private static List<Rule> list=new ArrayList<>();
    private static  StringBuilder result=new StringBuilder();
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String line=in.nextLine();
        String[] linetemp=blankSplit(line);
        //读取规则数量
        int n=Integer.parseInt(linetemp[0]);
        //读取地址数量
        int m=Integer.parseInt(linetemp[1]);
        //将规则存入静态数组list中
        for (int i=0;i<n;i++){
            String line2=in.nextLine();
            String[] tempstr=blankSplit(line2);
            String rule=tempstr[0];
            String name=tempstr[1];
            Rule rule1=new Rule(rule,name);
            list.add(rule1);
        }
        for (int j=0;j<m;j++) {
            //获取地址
            String temp=in.nextLine();
            boolean flag=false;
            for (int k=0;k<n;k++){
                String rule=list.get(k).rule;
                if(match(rule,temp)){
                    flag=true;
                    System.out.println(list.get(k).name+" "+result.toString());
                    break;
                }
                result.setLength(0);
            }
            if (!flag){
                System.out.println(404);
            }
        }
    }
    public static Boolean match(String rule,String url){

        int k1=0,k2=0,len1=rule.length(),len2=url.length();
        while (k1<len1&&k2<len2){
            if (rule.charAt(k1)==url.charAt(k2)){
                k1++;
                k2++;
                continue;
            }
            if (rule.charAt(k1++)!='<'){
                return false;
            }
            if (rule.charAt(k1)=='i'){
                boolean first=true,flag=false;
                while (url.charAt(k2)!=' '&&url.charAt(k2)>='0'&&url.charAt(k2)<='9'){
                    flag=true;
                    if (first){
                        if (url.charAt(k2)!='0'){
                            result.append(url.charAt(k2));
                        }
                        k2++;
                        first=false;
                    }else {
                        result.append(url.charAt(k2));
                        k2++;
                    }
                }
                if (!flag) {
                    return false;
                }
                k1+=4;
                result.append(" ");
                continue;
            }
            if (rule.charAt(k1)=='s'){
                boolean flag2 = false;
                while (url.charAt(k2)!=' '&&url.charAt(k2)!='/'){
                    flag2=true;
                    result.append(url.charAt(k2));
                    k2++;
                }
                if (!flag2) {
                    return false;
                }
                k1+=4;
                result.append(" ");
                continue;
            }
            if(rule.charAt(k1) == 'p'){
                while (k2< url.length()){
                    result.append(url.charAt(k2));
                    k2++;
                }
                return true;
            }
        }
        return (k1==len1&&k2==len2);
    }
    static class Rule{
        String rule;
        String name;

        public Rule(String rule, String name) {
            this.rule = rule;
            this.name = name;
        }
    }

    private static String[] blankSplit(String temp){
        String[] words=temp.split(" ");
        return words;
    }
}

100分代码：

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

public class url3
{
    private static List<Rule> list=new ArrayList<>();
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String line=in.nextLine();
        String[] linetemp=blankSplit(line);
        int n=Integer.parseInt(linetemp[0]);
        int m=Integer.parseInt(linetemp[1]);
        for (int i=0;i<n;i++){
            String line2=in.nextLine();
            String[] tempstr=blankSplit(line2);
            String rule=tempstr[0];
            String name=tempstr[1];
            Rule rule1=new Rule(rule,name);
            list.add(rule1);
        }
        for (int j=0;j<m;j++) {
            String temp=in.nextLine();
            boolean flag=false;
            for (int k=0;k<n;k++){
                String rule=list.get(k).rule;
                if(match(rule,temp,false)){
                    flag=true;
                    System.out.print(list.get(k).name);
                    match(rule,temp,true);
                    System.out.println();
                    break;
                }
            }
            if (!flag){
                System.out.println(404);
            }
        }
    }
    private static Boolean match(String rule, String url,boolean flag) {
        int k1 = 0, k2 = 0, len1 = rule.length(), len2 = url.length();
        while (k1 < len1 && k2 < len2) {
            if (rule.charAt(k1) == url.charAt(k2)) {
                k1++;
                k2++;
                continue;
            }
            if (rule.charAt(k1++) != '<') {
                return false;
            }
            if (flag) {
                System.out.print(" ");
            }
            if (rule.charAt(k1) == 'i') {
                boolean flag2 = false;
                while (k2 < url.length() && url.charAt(k2) != ' ' && url.charAt(k2) >= '0' && url.charAt(k2) <= '9') {
                    if (url.charAt(k2) > '0') {
                        flag2 = true;
                    }
                    if (flag && flag2) {
                        System.out.print(url.charAt(k2));
                    }
                    k2++;
                }
                if (!flag2) {
                    return false;
                }
                k1 += 4;
                continue;
            }
            if (rule.charAt(k1) == 's') {
                boolean flag2 = false;
                while (k2 < url.length() && url.charAt(k2) != '/') {
                    flag2 = true;
                    if (flag) {
                        System.out.print(url.charAt(k2));
                    }
                    k2++;
                }
                if (!flag2) {
                    return false;
                }
                k1 += 4;
                continue;
            }
            if (rule.charAt(k1) == 'p') {
                if (flag) {
                    while (k2 < url.length()) {
                        System.out.print(url.charAt(k2++));
                    }
                }
                return true;
            }

        }
        return (k1 == len1 && k2 == len2);
    }


    static class Rule{
        String rule;
        String name;

        public Rule(String rule, String name) {
            this.rule = rule;
            this.name = name;
        }
    }

    private static String[] blankSplit(String temp){
        String[] words=temp.split(" ");
        return words;
    }
}

参考的帖子：https://blog.csdn.net/nameofcsdn/article/details/79945925

ccf url映射 基于JAVA实现（100分）

猜你喜欢

ccf url映射基于JAVA实现（100分）