TZOJ 挑战题库随机训练08（JAVA）

点击题号跳转

A2441 B2293 C1724 D3462 E1608

F5065 G2427 H5466 I5603 J3299

A.Work Reduction回到顶部

题意

n变成m，两种操作，减1花费A，整除2花费B，问最小花费

题解

n变成n/2，操作1需要花费(n-n/2)*A，操作2需要花费B，比大小决定，复杂度O(logn)

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        int t = sc.nextInt();
        for (int ca = 1; ca <= t; ca++) {
            System.out.println("Case " + ca);
            solver.solve(sc);
        }
    }

}

class Solution {

    class Node {
        String name;
        int sumCost;

        Node(String name, int sumCost) {
            this.name = name;
            this.sumCost = sumCost;
        }
    }

    public void solve(Scanner sc) {
        int n = sc.nextInt();
        int m = sc.nextInt();
        int agencies = sc.nextInt();
        sc.nextLine();// 读回车
        List<Node> list = new ArrayList<Node>();
        for (int i = 0; i < agencies; i++) {
            String s = sc.nextLine();
            String[] str = s.split(":");
            String[] str1 = str[1].split(",");
            int aCost = Integer.valueOf(str1[0]);
            int bCost = Integer.valueOf(str1[1]);
            int val = n;
            int sumCost = 0;
            while (val > m) {
                int updateTo = val / 2;
                int aSumCost = aCost * (val - updateTo);
                if (updateTo >= m && aSumCost > bCost) {
                    sumCost += bCost;
                    val = updateTo;
                } else {
                    // 剩下一段全A
                    sumCost += (val - m) * aCost;
                    break;
                }
            }
            list.add(new Node(str[0], sumCost));
        }

        Collections.sort(list, new Comparator<Node>() {
            public int compare(Node o1, Node o2) {
                if (o1.sumCost > o2.sumCost)
                    return 1;
                else if (o1.sumCost == o2.sumCost) {
                    if (o1.name.compareTo(o2.name) > 0)
                        return 1;
                    else
                        return -1;
                }
                else return -1;
            }
        });

        for (int i = 0; i < list.size(); i++)
            System.out.println(list.get(i).name + " " + list.get(i).sumCost);
    }

}

B.Collecting Beepers回到顶部

题意

10个点，给个起点，问经过每个点再回到起点的最小距离

题解

爆搜，最后加上到起点的距离，复杂度O(2^10)

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        int t = sc.nextInt();
        for (int ca = 1; ca <= t; ca++) {
            solver.solve(sc);
        }
    }

}

class Solution {

    private int[] x;
    private int[] y;
    private boolean[] vis;
    private int q;
    private int sx, sy;
    private int min;

    public void solve(Scanner sc) {
        int n = sc.nextInt();
        int m = sc.nextInt();
        sx = sc.nextInt();
        sy = sc.nextInt();
        q = sc.nextInt();
        x = new int[q];
        y = new int[q];
        vis = new boolean[q];
        min = 1000000000;
        for (int i = 0; i < q; i++) {
            x[i] = sc.nextInt();
            y[i] = sc.nextInt();
        }
        dfs(0, 0, sx, sy);
        System.out.println("The shortest path has length " + min);
    }

    private void dfs(int step, int cost, int ux, int uy) {
        if (step == q) {
            min = Math.min(min, cost + Math.abs(ux - sx) + Math.abs(uy - sy));
            return;
        }
        if (cost <= min) {
            for (int i = 0; i < q; i++) {
                if (!vis[i]) {
                    vis[i] = true;
                    dfs(step + 1, cost + Math.abs(x[i] - ux) + Math.abs(y[i] - uy), x[i], y[i]);
                    vis[i] = false;
                }
            }
        }
    }
}

C.Guess how much I love you?回到顶部

题意

n个串，按TOJ和JOT的个数大到小排序，若个数相同按长度大到小排序，若长度相同按字典序小到大排序，串总长<=10000

题解

处理出每个串的TOJ和JOT的个数，调用Collections.sort方法排序，匿名内部类new Comparator，然后排序需要把@Override去掉，复杂度O(10000)

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        int t = sc.nextInt();
        for (int ca = 1; ca <= t; ca++) {
            solver.solve(sc);
        }
    }

}

class Solution {
    class Node {
        String s;
        int num;
        Node() {
            num = 0;
        }
    }
    public void solve(Scanner sc) {
        int n = sc.nextInt();
        sc.nextLine(); // 读回车
        List<Node> list = new ArrayList<Node>();
        for (int i = 0; i < n; i++) {
            Node node = new Node();
            node.s = sc.nextLine();
            for (int j = 2; j < node.s.length(); j++) {
                if ("TOJ".equals(node.s.substring(j - 2, j + 1)) || "JOT".equals(node.s.substring(j - 2, j + 1))) {
                    node.num++;
                }
            }
            list.add(node);
        }
        Collections.sort(list, new Comparator<Node>() {
            public int compare(Node o1, Node o2) {
                // 正数交换 其余不换
                if (o1.num < o2.num) {
                    return 1;
                } else if (o1.num > o2.num){
                    return -1;
                } else {
                    if (o1.s.length() < o2.s.length())
                        return 1;
                    else if (o1.s.length() == o2.s.length())
                        if (o1.s.compareTo(o2.s) < 0)
                            return 1;
                        else
                            return -1;
                    else {
                        return -1;
                    }
                }
            }
        });
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i).s);
        }
    }
}

D.F**king string!回到顶部

题意

n(<=10)个串长度最大100，再给一个错误串，n个串都取前k个字符和错误串的最长公共子串>=d，求最小的k，若不存在-1

题解

易得k的范围[d,n个串+错误串的最小长度]，枚举n个串

对于一个串，存在一个k，使得满足最长公共子串>=d，那么k+1也满足（优化）

可以用dp求出最长公共子串长度即可，复杂度O(100^3)

PS：一开始以为错误串也要去前k个，幸好反应过来了

代码

import java.util.*;

public class Main {

    private Scanner sc;
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        while (solver.solve(sc) != -1) {

        }
    }

}

class Solution {

    String[] str;
    public int solve(Scanner sc) {
        int n = sc.nextInt();
        int d = sc.nextInt();
        if (n == 0 && d == 0) return -1;
        str = new String[n + 5];
        int upLength = 1000000000;
        for (int i = 0; i < n; i++) {
            str[i] = sc.next();
            upLength = Math.min(upLength, str[i].length());
        }
        str[n] = sc.next();
        upLength = Math.min(upLength, str[n].length());
        boolean[] vis = new boolean[n];
        for (int i = 0; i < n; i++) vis[i] = false;
        int k = -1;
        for (int len = d; len <= upLength; len++) {
            boolean ok = true;
            for (int i = 0; i < n; i++) {
                // 如果之前的len就合法，不用判断了
                if (vis[i]) continue;
                // str[n]和str[i]的[0,len)最长公共子串
                int common = LCS(str[n], str[i].substring(0, len));
                if (common < d) {
                    ok = false;
                    break;
                } else {
                    vis[i] = true;
                }
            }
            if (ok) {
                k = len;
                break;
            }
        }
        System.out.println(k);
        return 1;
    }

    private int LCS(String s1, String s2) {
        int[][] dp = new int[s1.length()][s2.length()];
        int maxLength = 0;
        for (int i = 0; i < s1.length(); i++)
            for (int j = 0; j < s2.length(); j++) {
                if (s1.charAt(i) == s2.charAt(j))
                    if (i > 0 && j > 0) dp[i][j] = dp[i - 1][j - 1] + 1;
                    else dp[i][j] = 1;
                else
                    dp[i][j] = 0;
                maxLength = Math.max(maxLength, dp[i][j]);
            }
        return maxLength;
    }
}

E.Distance Statistics回到顶部

题意

给一张图n，m<=10^5，求点对距离<=k的数量

题解

点分治模板题

点分治用在去掉某个点后，这个点不影响对答案的贡献

算法流程大概是，求出树的重心，求出重心到每个点的距离，双指针计算方案，容斥掉两点同向的情况，再移除重心，同理计算剩下的子树

复杂度O(nlog^2n)

PS：服务器jdk版本改成1.8，java代码已经可以过了

代码

import java.util.*;

public class Main {

    private Scanner sc;

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        solver.solve(sc);
    }

}

class Solution {

    private final int N = 100005;

    private int n, m, k;
    private int MIN, ans, root;
    private int[] mx = new int[N];
    private int[] sz = new int[N];
    private boolean[] vis = new boolean[N];
    private List<Integer> dis = new ArrayList<Integer>();
    private List< ArrayList<Node> > G = new ArrayList< ArrayList<Node> >();

    class Node {
        int v, w;

        Node(int v, int w) {
            this.v = v;
            this.w = w;
        }
    }

    private void init() {
        for (int i = 0; i < N; i++) {
            G.add(new ArrayList<Node>());
            vis[i] = false;
        }
    }

    public void solve(Scanner sc) {
        n = sc.nextInt();
        m = sc.nextInt();
        init();
        for (int i = 0; i < m; i++) {
            int u = sc.nextInt() - 1;
            int v = sc.nextInt() - 1;
            int w = sc.nextInt();
            sc.next();
            G.get(u).add(new Node(v, w));
            G.get(v).add(new Node(u, w));
        }
        k = sc.nextInt();
        dfs(0);
        System.out.println(ans);
    }

    private void dfs(int u) {
        MIN = n;
        dfsSz(u, u);
        dfsRoot(u, u, u);
        int gri = root;
        //System.out.println("grivate:" + gri);
        ans += cal(gri, 0);
        //System.out.println("u:" + u);
        //System.out.println("ans:" + ans);
        vis[root] = true;
        for (int i = 0; i < G.get(gri).size(); i++) {
            int v = G.get(gri).get(i).v;
            int w = G.get(gri).get(i).w;
            if (!vis[v]) {
                ans -= cal(v, w);
                dfs(v);
            }
        }
    }

    private void dfsSz(int u, int fa) {
        sz[u] = 1;
        mx[u] = 0;
        for (int i = 0; i < G.get(u).size(); i++) {
            int v = G.get(u).get(i).v;
            if (!vis[v] && v != fa) {
                dfsSz(v, u);
                sz[u] += sz[v];
                mx[u] = Math.max(mx[u], sz[v]);
            }
        }
    }

    private void dfsRoot(int r, int u, int fa)//r为子树的根
    {
        //子树的其余节点
        if (sz[r] - sz[u] > mx[u])
            mx[u] = sz[r] - sz[u];
        //root为重心
        if (mx[u] < MIN) {
            MIN = mx[u];
            root = u;
        }
        for (int i = 0; i < G.get(u).size(); i++) {
            int v = G.get(u).get(i).v;
            if (!vis[v] && v != fa)
                dfsRoot(r, v, u);
        }
    }

    private void dfsDis(int u, int fa, int d) {
        //System.out.println("u:" + u +" fa:" + fa + " d:" + d);
        dis.add(d);
        for (int i = 0; i < G.get(u).size(); i++) {
            int v = G.get(u).get(i).v;
            int w = G.get(u).get(i).w;
            //System.out.println("i=" + i + " v=" + v);
            if (!vis[v] && v != fa)
                dfsDis(v, u, d + w);
        }
    }

    private int cal(int r, int w) {
        int ret = 0;
        dis.clear();
        dfsDis(r, r, w);
        Collections.sort(dis);
        int L = 0, R = dis.size() - 1;
        while (L < R) {
            while (dis.get(L) + dis.get(R) > k && L < R) R--;
            ret += R - L;
            L++;
        }
        return ret;
    }
}

#include<bits/stdc++.h>
using namespace std;

const int N=1e5+5;
vector< pair<int,int> >G[N];
int mx[N],sz[N],vis[N],dis[N],ans,MIN,n,k,num,root;
void dfssz(int u,int fa)
{
    sz[u]=1;
    mx[u]=0;
    for(int i=0;i<G[u].size();i++)
    {
        int v=G[u][i].first;
        if(!vis[v]&&v!=fa)
        {
            dfssz(v,u);
            sz[u]+=sz[v];
            mx[u]=max(mx[u],sz[v]);
        }
    }
}
void dfsroot(int r,int u,int fa)//r为子树的根 
{
    if(sz[r]-sz[u]>mx[u])//子树的其余节点 
        mx[u]=sz[r]-sz[u];
    if(mx[u]<MIN)//root为重心
        MIN=mx[u],root=u;
    for(int i=0;i<G[u].size();i++)
    {
        int v=G[u][i].first;
        if(!vis[v]&&v!=fa)
            dfsroot(r,v,u);
    }
}
void dfsdis(int u,int fa,int d)
{
    dis[num++]=d;
    for(int i=0;i<G[u].size();i++)
    {
        int v=G[u][i].first;
        int w=G[u][i].second;
        if(!vis[v]&&v!=fa)
            dfsdis(v,u,d+w);
    }
}
int cal(int r,int w)
{
    int ret=0;
    num=0;
    dfsdis(r,r,w);
    sort(dis,dis+num);
    int L=0,R=num-1;
    while(L<R)
    {
        while(dis[L]+dis[R]>k&&L<R)R--;
        ret+=R-L;    
        L++;
    }
    return ret;
}
void dfs(int u)
{
    MIN=n;
    dfssz(u,u);
    dfsroot(u,u,u);
    int Grivate=root;
    ans+=cal(Grivate,0);
    vis[root]=1;
    for(int i=0;i<G[Grivate].size();i++)
    {
        int v=G[Grivate][i].first;
        int w=G[Grivate][i].second;
        if(!vis[v])
        {
            ans-=cal(v,w);
            dfs(v);
        }
    }
}
int main(){
    int m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        int u,v,w;
        scanf("%d%d%d%*s",&u,&v,&w);
        G[u-1].push_back({v-1,w});
        G[v-1].push_back({u-1,w});
    }
    scanf("%d",&k);
    dfs(0);
    printf("%d",ans);
    return 0;
}

F.最长连续子序列回到顶部

题意

求最长连续子序列使得和是7的倍数

题解

这样想，如果[1,i-1]模7为3，如果[1,j]模7也为3，那么就说明[i,j]模7为0

dp[i]表示[1,i]的和模7的第一次出现的位置，那么答案就是后面出现的最大距离，复杂度O(n)

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] dp = new int[8];
        int max = 0, sum = 0;
        for (int i = 1; i <= n; i++) {
            int x = sc.nextInt();
            sum = (sum + x) % 7;
            if (dp[sum] != 0)
                max = Math.max(max, i - dp[sum]);
            if (dp[sum] == 0)
                dp[sum] = i;
        }
        System.out.println(max);
    }
}

G.Guessing Game回到顶部

题意

猜数字1-10，问出题的是否诚实

题解

根据too low和too high确定范围，根据right on判断是否在范围内，复杂度O(1)

PS：java中Scanner的getLine方法会读回车，所以得先把回车读掉

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            Boolean[] vis = new Boolean[11];
            for (int i = 1; i <= 10; i++)
                vis[i] = false;
            Boolean dishonest = true;
            int guass;
            while (true) {
                guass = sc.nextInt();
                if (guass == 0) break;
                sc.nextLine();// 读回车
                String s = sc.nextLine();
                if ("too high".equals(s)) {
                    for (int i = guass; i <= 10; i++)
                        vis[i] = true;
                } else if ("too low".equals(s)) {
                    for (int i = 1; i <= guass; i++)
                        vis[i] = true;
                } else {
                    if (vis[guass]) dishonest = false;
                    break;
                }
            }
            if (guass == 0) break;
            if (!dishonest) System.out.println("Stan is dishonest");
            else System.out.println("Stan may be honest");
        }
    }
}

H.学习之我要直线回到顶部

题意

给你2<=n<=10^5个点，问是否存在两条平行直线穿过所有点

题解

首先当n<=3一定满足

假设存在，那么取出三个点，点1，点2，点3，构造直线12，直线13，直线23，一定能够找到其中一条平行线

为什么？如果1、2不是，那么要么13在平行线上，要么23在平行线上

那么枚举12，13，23把直线上的点都去掉，再看身下的点是否在一条直线上并平行，复杂度O(n)

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        Solution solver = new Solution();
        while (sc.hasNext()) {
            solver.solve(sc);
        }
    }

}

class Solution {

    private int[] x = new int[100005];
    private int[] y = new int[100005];
    private boolean[] vis = new boolean[100005];
    private int n;

    public void solve(Scanner sc) {
        n = sc.nextInt();
        for (int i = 0; i < n; i++) {
            x[i] = sc.nextInt();
            y[i] = sc.nextInt();
        }
        if ( n <= 3 || pd(0,1) || pd(0,2) || pd(1,2)) System.out.println("YES");
        else System.out.println("NO");
    }

    private boolean pd(int sPoint1, int sPoint2) {
        for (int i = 0; i < n; i++) vis[i] = false;
        int cnt = n;
        // 第一条线
        for (int i = 0; i < n; i++) if (check(sPoint1, sPoint2, i)) {
            vis[i] = true;
            cnt--;
        }
        if (cnt == 0) return true;
        for (int i = 0; i < n; i++) {
            if (!vis[i]) {
                // 第二条线
                vis[i] = true;
                cnt--;
                for (int j = i + 1; j < n; j++) if (!vis[j] && checkParallel(sPoint1, sPoint2, i, j)) {
                    vis[j] = true;
                    cnt--;
                }
                return cnt == 0;
            }
        }
        return false;
    }

    // 检查i，j，k是否三点共线
    private boolean check(int i, int j, int k) {
        return (long)(x[j] - x[i]) * (y[k] - y[i]) == (long)(x[k] - x[i]) * (y[j] - y[i]);
    }

    // 检查i，j和k，l是否平行
    private boolean checkParallel(int i, int j, int k, int l) {
        return (long)(x[j] - x[i]) * (y[l] - y[k]) == (long)(x[l] - x[k]) * (y[j] - y[i]);
    }

}

I.查询数据回到顶部

题意

n个数，m次查询，每次查询一个数是否存在

题解

hashset，复杂度O(Σm)

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        HashSet<Integer> hashSet = new HashSet<Integer>();
        for (int i = 0; i < n; i++) {
            hashSet.add(sc.nextInt());
        }
        for (int i = 0; i < m; i++) {
            if (hashSet.contains(sc.nextInt())) {
                System.out.println("Yes");
            } else {
                System.out.println("No");
            }
        }
    }
}

J.切蛋糕回到顶部

题意

每次竖直切一刀，求切n刀后可以把蛋糕分成几块

题解

由于大小不需要一样，那么第i+1刀肯定与前i刀都有交点，即多出i+1块，那么就变成等差数列求和，复杂度O(1)

代码

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()) {
            int n = sc.nextInt();
            System.out.println(1 + (1 + n) * n / 2);
        }
    }
}