csp URL映射 java实现

 

试题编号：	201803-3
试题名称：	URL映射
问题描述：	问题描述 　　URL 映射是诸如 Django、Ruby on Rails 等网页框架 (web frameworks) 的一个重要组件。对于从浏览器发来的 HTTP 请求，URL 映射模块会解析请求中的 URL 地址，并将其分派给相应的处理代码。现在，请你来实现一个简单的 URL 映射功能。 　　本题中 URL 映射功能的配置由若干条 URL 映射规则组成。当一个请求到达时，URL 映射功能会将请求中的 URL 地址按照配置的先后顺序逐一与这些规则进行匹配。当遇到第一条完全匹配的规则时，匹配成功，得到匹配的规则以及匹配的参数。若不能匹配任何一条规则，则匹配失败。 　　本题输入的 URL 地址是以斜杠 / 作为分隔符的路径，保证以斜杠开头。其他合法字符还包括大小写英文字母、阿拉伯数字、减号 -、下划线 _ 和小数点 .。例如，/person/123/ 是一个合法的 URL 地址，而 /person/123? 则不合法（存在不合法的字符问号 ?）。另外，英文字母区分大小写，因此 /case/ 和 /CAse/ 是不同的 URL 地址。 　　对于 URL 映射规则，同样是以斜杠开始。除了可以是正常的 URL 地址外，还可以包含参数，有以下 3 种： 　　字符串 <str>：用于匹配一段字符串，注意字符串里不能包含斜杠。例如，abcde0123。 　　整数 <int>：用于匹配一个不带符号的整数，全部由阿拉伯数字组成。例如，01234。 　　路径 <path>：用于匹配一段字符串，字符串可以包含斜杠。例如，abcd/0123/。 　　以上 3 种参数都必须匹配非空的字符串。简便起见，题目规定规则中 <str> 和 <int> 前面一定是斜杠，后面要么是斜杠，要么是规则的结束（也就是该参数是规则的最后一部分）。而 <path> 的前面一定是斜杠，后面一定是规则的结束。无论是 URL 地址还是规则，都不会出现连续的斜杠。 输入格式 　　输入第一行是两个正整数 n 和 m，分别表示 URL 映射的规则条数和待处理的 URL 地址个数，中间用一个空格字符分隔。 　　第 2 行至第 n+1 行按匹配的先后顺序描述 URL 映射规则的配置信息。第 i+1 行包含两个字符串 pi 和 ri，其中 pi 表示 URL 匹配的规则，ri 表示这条 URL 匹配的名字。两个字符串都非空，且不包含空格字符，两者中间用一个空格字符分隔。 　　第 n+2 行至第 n+m+1 行描述待处理的 URL 地址。第 n+1+i 行包含一个字符串 qi，表示待处理的 URL 地址，字符串中不包含空格字符。 输出格式 　　输入共 m 行，第 i 行表示 qi 的匹配结果。如果匹配成功，设匹配了规则 pj ，则输出对应的 rj。同时，如果规则中有参数，则在同一行内依次输出匹配后的参数。注意整数参数输出时要把前导零去掉。相邻两项之间用一个空格字符分隔。如果匹配失败，则输出 404。 样例输入 5 4 /articles/2003/ special_case_2003 /articles/<int>/ year_archive /articles/<int>/<int>/ month_archive /articles/<int>/<int>/<str>/ article_detail /static/<path> static_serve /articles/2004/ /articles/1985/09/aloha/ /articles/hello/ /static/js/jquery.js 样例输出 year_archive 2004 article_detail 1985 9 aloha 404 static_serve js/jquery.js 样例说明 　　对于第 1 个地址 /articles/2004/，无法匹配第 1 条规则，可以匹配第 2 条规则，参数为 2004。 　　对于第 2 个地址 /articles/1985/09/aloha/，只能匹配第 4 条规则，参数依次为 1985、9（已经去掉前导零）和 aloha。 　　对于第 3 个地址 /articles/hello/，无法匹配任何一条规则。 　　对于第 4 个地址 /static/js/jquery.js，可以匹配最后一条规则，参数为 js/jquery.js。 数据规模和约定 　　1 ≤ n ≤ 100，1 ≤ m ≤ 100。 　　所有输入行的长度不超过 100 个字符（不包含换行符）。 　　保证输入的规则都是合法的。

在解决这个问题上我想出了两种思路：

考试的时候想到的是枚举，对规则进行直接存储，然后对测试数据需要做一些的处理，以”/“为界限分割url地址，从前往后扫描每一个token，判断token能否配<int><str>或是<path>，分别用<int><str><path>进行填充，枚举出能够产生的所有规则。问题就是如果一个url地址存在多个匹配的规则时，不能保证按照顺序匹配，只能通过一小部分的测试用例。

 

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


//由于字符串的替换从前往后，只覆盖了替换一个字段的情况
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		String temp=sc.nextLine();
		int input1=Integer.parseInt(temp.split(" ")[0]);
		int input2=Integer.parseInt(temp.split(" ")[1]);
		List<RuleCore> rule=new ArrayList<RuleCore>();//存储规则
		List<TestCore> test=new ArrayList<TestCore>();//存储测试用例

		// 输入数据
		//*输入规则
		while(input1-->0)
		{
			String temp1=sc.nextLine().trim();
			String[] temp2=temp1.split(" ");
			RuleCore core=new RuleCore();
			core.url=temp2[0];
			core.value=temp2[1];
			rule.add(core);
		}
		while(input2-->0)
		{
			TestCore core=new TestCore();
			core.url=sc.nextLine().trim();
			test.add(core);
		}
		input2=test.size();
		//输入完毕

		System.out.println("开始");

		//逐条处理测试用例
		//生成中间数据

		for(int i=0;i<test.size();i++)
		{
			String str=test.get(i).url;
			//以斜杠分词
			String[] data=str.split("/");
			for(int k=0;k<data.length;k++)
			{
				if(data[k].trim()==null||data[k].equals(""))
				{
					continue;          
				}
				//添加<int>
				if(isNumber(data[k]))
				{
					//如果这个元素可以转换成int，就替换成<int>
					String temp2=pinjie(test.get(i).url,k,"<int>");
					//添加int
					test.get(i).list.add(temp2);
				}
				String temp2=pinjie(test.get(i).url,k,"<str>");
				//添加string
				test.get(i).list.add(temp2);
			}
			//输出中间数据
			//			for(int p=0;p<test.get(i).list.size();p++)
			//			{
			//				System.out.println(test.get(i).list.get(p));
			//			}

		}


		//进行匹配
		for(int i=0;i<test.size();i++)
		{
			List<String> ruletemp=new ArrayList<String>();

			for(int j=0;j<rule.size();j++)
			{
				ruletemp.add(rule.get(j).url);
			}

			List<String> list=test.get(i).list;
			if(inList(ruletemp,list))
			{
				System.out.println("true");
			}
			else {
				System.out.println("404");
			}



		}

	}

	public static boolean inList(List<String> list,List<String> list1)
	{
		for(int i=0;i<list.size();i++)
		{
			for(int j=0;j<list1.size();j++)
			{
				System.out.println(list.get(i)+":"+list1.get(j));
				if(list.get(i).trim().equals(list1.get(j).trim()))
					{

					return true;
					}
			}

		}

		return false;
	}

	//根据空格split,提供index 拼接
	public static String pinjie(String str,int index,String key)
	{
		String[] temp=str.split("/");
		String keep="/";
		for(int i=0;i<temp.length;i++)
		{
			if(temp[i].trim()==null||temp[i].equals(""))
			{
				continue;
			}
			if(i==index)
			{
				keep+=key+"/";
			}
			else {
				keep+=temp[i]+"/";
			}
		}
		return keep;
	}

	public static String newpath(String str,int index)
	{
		String[] temp=str.split("/");
		String keep="/";
		for(int i=0;i<=index;i++)
		{
			if(temp[i].trim()==null||temp[i].equals(""))
			{
				continue;
			}
			keep+=temp[i]+"/";
		}
		return keep+"<path>";
	}

	//判断是否是int
	public static boolean isNumber(String s)
	{
		try
		{
			int a=Integer.parseInt(s);
		}
		catch(Exception e)
		{
			return false;
		}
		return true;
	}
	//规则存储结构
	public static class RuleCore
	{
		String url;
		String value;
	}
	//测试用例存储结构
	public static class TestCore
	{
		String url;
		List<String> list=new ArrayList<String>(); 
	}
}


//将匹配和输出分别处理

为了能够从头到尾的进行匹配，我们还是应该考虑从头到尾查找的流程；

通配符的引入是这道题的一个难点，不能严格按照字符串去匹配，不过我们可以直接使用正则表达式来做，把规则转化成对应的正则表达式，在用string类的match方法就能进行匹配，匹配完成后，在比对参数并输出

需要特别注意的“/”结尾的情况需要特别的考虑，/123/<str>不能够匹配/123/123/的情况

所有的测试用例中大概有40%是含有以反斜杠结尾的用例

<int> 对应 [0-9]+
<str> 对应 [0-9_.a-zA-Z-]+
<path> 对应 [0-9a-zA-Z_./-]*

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

public class Main{
    static List<Url> ruleList = new ArrayList<Url>();
    static List<String> testList = new ArrayList<String>();

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int ruleNum = sc.nextInt();
        int testNum = sc.nextInt();

        //input data,输入规则
        for (int i = 0; i < ruleNum; i++) {
            Url url = new Url(sc.next(), sc.next());
            ruleList.add(url);
        }

        //input test,输入要匹配的数据
        for (int i = 0; i < testNum; i++) {
            String str = sc.next();
            testList.add(str);
        }

        //make regex，为每一条规则生成一个正则表达式
        for (int i = 0; i < ruleNum; i++) {
            Url url = ruleList.get(i);
            url.setRegex(getRegex(url.getName()));
            ruleList.set(i, url);
        }

        for (String string : testList) {
            boolean searched = false;
            Url searchedUrl = null;

            for (Url url : ruleList) {
                if (string.matches(url.getRegex())) {
                    searched = true;
                    searchedUrl = url;
                    break;
                }
            }
            //未成功匹配
            if (!searched) {
                System.out.println("404");
            } else {
                String printStr = searchedUrl.getValue() + " " + getPrint(searchedUrl.getName(), string);
                System.out.println(printStr.trim());

            }
        }
    }

    public static String getPrint(String rule, String test) {
        String[] ruleArray = rule.split("/");
        String[] testArray = test.split("/");
        String value = "";
        for (int i = 0; i < ruleArray.length; i++) {
            String str = ruleArray[i];
            if (str.equals("")) {
                continue;
            } else if (str.equals("<str>")) {
                value += testArray[i] + " ";
            } else if (str.equals("<int>")) {
                value += String.valueOf(Integer.parseInt(testArray[i])) + " ";
            } else if (str.equals("<path>")) {
                for (int j = i; j < testArray.length; j++) {
                    if (j == testArray.length - 1 && !test.endsWith("/")) {
                        value += testArray[j];
                    } else {
                        value += testArray[j] + "/";
                    }
                }
            } else {
                continue;
            }
        }
        return value.trim();
    }

    public static String getRegex(String str) {
        String[] data = str.split("/");
        String regexStr = "/";
        for (int i = 0; i < data.length; i++) {
            String string = data[i];
            if (string.equals("")) { //！我们没有考虑连着两个反斜杠的情况
                continue;
            } else if (string.equals("<int>")) {
                regexStr += "[0-9]+";  //匹配数字
                regexStr += i == data.length - 1 && !str.endsWith("/") ? "" : "/";
            } else if (string.equals("<str>")) {
                regexStr += "[0-9_.a-zA-Z-<>]+";
                regexStr += i == data.length - 1 && !str.endsWith("/") ? "" : "/";
            } else if (string.equals("<path>")) {
                regexStr += "[0-9a-zA-Z_./-<>]*";
            } else {
                regexStr += string;
                regexStr += i == data.length - 1 && !str.endsWith("/") ? "" : "/";
            }
        }

//        System.out.println("r: " + regexStr);
        return regexStr;
    }

    public static boolean isInt(String str) {
        try {
            int a = Integer.parseInt(str);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    public static boolean find(List<String> list, String str) {
        for (String data : list) {
            if (data.startsWith(str)) {
                return true;
            }
        }
        return false;
    }

    public static class Url {
        String name;
        String value;
        String regex;

        public Url(String name, String value) {
            this.name = name;
            this.value = value;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }

        public String getRegex() {
            return regex;
        }

        public void setRegex(String regex) {
            this.regex = regex;
        }

    }
}