ACM

最新推荐文章于 2019-04-09 11:31:32 发布
最新推荐文章于 2019-04-09 11:31:32 发布
阅读量223 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： javaACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wujiandao000/article/details/79569315 

/**
 * 数飞机
 */
public class CountPlane {


    public static void main(String[] args) {
        int n = 4;
        int[] arCount = new int[24];
        for (int i = 0; i < arCount.length; i++) {
            arCount[i] = 0;
        }
        int[][] arr = { { 1, 10 }, { 2, 3 }, { 5, 8 }, { 4, 7 } };
        int max = 0;
        for (int i = 0; i < n; i++) {
            for (int j = arr[i][0]; j <= arr[i][1]; j++) {
                arCount[j] = arCount[j] + 1;
                if (arCount[j] > max) {
                    max = arCount[j];
                }
            }
        }
        System.out.println("同时：" + max);
    }

}





/**
 * 判断单链表是否有环
 */
public class LinkedLoop {


    // 内部静态类定义节点类
    static class Node {
        int val;
        Node next;


        public Node(int val) {
            this.val = val;
        }
    }


    // 方法一，通过hashMap的存储唯一性进行判断
    private static boolean hasRingOfLinked(Node head) {
        HashMap<Node, Node> nodeMap = new HashMap<Node, Node>();
        nodeMap.put(head, head);
        Node temNode = head.next;
        while (temNode != null) {
            System.out.println(nodeMap.get(temNode));
            if (nodeMap.get(temNode) != null) {
                System.out.println("--val:" + nodeMap.get(temNode).val);
            }
            if (nodeMap.get(temNode) != null) {
                return true;
            }
            if (temNode.next == null) {
                return false;
            }
            nodeMap.put(temNode, temNode);
            temNode = temNode.next;
        }


        return true;
    }


    // 方法二，通过环比追跑进行判断
    private static boolean hasRingOfLinked2(Node head) {
        Node temNode1 = head;
        Node temNode2 = head.next;
        if (temNode2 == null) {
            return true;
        }
        while (temNode1 != temNode2) {
            if (temNode1.next != null) {
                temNode1 = temNode1.next;
            } else {
                return false;
            }
            if (temNode2.next.next != null) {
                temNode2 = temNode2.next.next;
            } else {
                return false;
            }
        }


        return true;
    }


    public static void main(String[] args) {
        Node head = new Node(0);
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        Node node6 = new Node(6);


        head.next = node1;
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        // node5.next = node6;


        // boolean res = hasRingOfLinked(head);
        boolean res = hasRingOfLinked2(head);
        System.out.println(res);
    }


}







/**
 * 求一个字符串中的最长不重复子串
 */
public class LongestSubStr {


    public static void main(String[] args) {
        // 测试最大不重复子串函数
        String str = "abcdaefgha";
        // System.out.println(getLongSubStr(str));


        // 测试回文字符串函数
        String str2 = "abcddcba";
        // System.out.println("是否回文？：" + find(str2.toCharArray(), 0,
        // str2.length() - 1));


        // 测试分解质数
        int x = 1000;
        System.out.print(x + " = ");
        prim(x, 2);
    }


    // 分解质数
    private static void prim(int m, int n) {
        if (m >= n) {
            while (m % n != 0) {
                n++;
            }
            m /= n;
            prim(m, n);
            if (m == n) {
                System.out.print("*" + n);
            } else {
                System.out.print("*" + n);
            }
        }
    }


    // 递归实现判断一个字符串是否是回文字符串
    private static boolean find(char[] cArr, int start, int end) {
        if (cArr.length == 0) {
            return true;
        }
        if (end <= start) {
            if (end == start || cArr[start] == cArr[end]) {
                return true;
            } else {
                return false;
            }
        } else if (cArr[start] == cArr[end]) {
            return find(cArr, start + 1, end - 1);
        }
        return false;
    }


    // 求一个字符串中的最大不重复子串
    private static int getLongSubStr(String str) {
        int max = 0;
        int temMax = 0;


        // 定义一个hashMap记录每个不重复的字符
        HashMap<Character, Integer> cHashMap = new HashMap<>();
        // 转换为字符数组
        char[] chs = str.toCharArray();


        for (int i = 0; i < chs.length; i++) {
            // 若map集合中包含该值
            if (cHashMap.containsKey(chs[i])) {
                if (temMax > max) {
                    max = temMax;
                }
                // 更新临时最大值
                temMax = i - cHashMap.get(chs[i]);
                // 更新map中最新出现该字符的位置
                cHashMap.put(chs[i], i);
                continue;
            }
            temMax++;
            // 新字符
            cHashMap.put(chs[i], i);
        }


        return max > temMax ? max : temMax;
    }


}





/**
 * 计算子数组的最大乘积
 */
public class MaxMulity {


    public static void main(String[] args) {
        double[] arr = { -2.5, 3, 0, 4, 0.5, 6, -2 };
        System.out.println(getMaxMulity(arr));
    }


    private static double getMaxMulity(double[] arr) {
        double maxNum = arr[0];
        double minNum = arr[0];
        
        double maxEnd = arr[0];
        double minEnd = arr[0];


        double res = 0;


        for (int i = 1; i < arr.length; i++) {
            maxNum = maxEnd * arr[i];
            minNum = minEnd * arr[i];
            // 计算本次循环中的最大与最小
            maxEnd = Math.max((Math.max(maxNum, minNum)), arr[i]);
            minEnd = Math.min((Math.min(maxNum, minNum)), arr[i]);


            // 再次计算最大值
            res = Math.max(maxEnd, res);
            System.out.println("循环最大：" + res + "   ,最小：" + minEnd);
        }


        return res;
    }


}



/**
 * 最大子数组和
 */
public class MaxSumSubArrry {


    public static void main(String[] args) {
        int[] arr = { -1, -3, -2, -1, -1, -2, -2 };
        int sum1 = 0;
        int sum2 = 0;
        int sumTwo = maxSum(arr, 0, 0) + maxSum(arr, 1, arr.length - 1);
        for (int i = 1; i < arr.length - 2; i++) {
            sum1 = maxSum(arr, 0, i);
            sum2 = maxSum(arr, i + 1, arr.length - 1);
            if ((sum1 + sum2) > sumTwo) {
                sumTwo = sum1 + sum2;
            }
        }


        System.out.println("两串和：" + sumTwo);
    }


    private static int maxSum(int[] arr, int start, int end) {
        int sum = arr[start];
        int temSum = 0;
        int maxFlag = arr[start];
        for (int i = start; i <= end; i++) {
            if (arr[i] > maxFlag) {
                maxFlag = arr[i];
            }
            temSum += arr[i];
            if (temSum < 0) {
                temSum = 0;
                continue;
            }
            if (sum < temSum) {
                sum = temSum;
            }
        }
        if (sum < maxFlag) {
            sum = maxFlag;
        }
        return sum;
    }
}





/**
 * 求一串数组的中位数
 */
public class MedianOfSub {


    public static void main(String[] args) {
        int[] arr = { 3, 2, 4, 6, 5 };
        int k = 3;
        for (int i = 0; i <= arr.length - k; i++) {
            System.out.println(getMedian(arr, i, k));
        }
    }


    private static int getMedian(int[] arr, int start, int k) {
        Arrays.sort(arr, start, (start + k));
        if (k % 2 == 0) {
            return arr[k / 2 + start - 1];
        }
        return arr[k / 2 + start];
    }
}





/**
 * 计算两个整形数组的最小的差
 */
public class MinBetwwnOfTwoArr {


    public static void main(String[] args) {


    }


    int getMinOfTwoArr(int[] A, int[] B) {
        int min = Math.abs(A[0] - B[0]);
        Arrays.sort(A);
        Arrays.sort(B);
        for (int i = 0; i < A.length; i++) {


        }


        return min;
    }


}





/**
 * 求最小工人合作时间
 */
public class MinWorkerTime {


    public static void main(String[] args) {
        int N = 4;
        int cost[][] = {
                { 2, 12, 5, 32 }, // 行号：任务序号，列号：工人序号
                { 3, 15, 7, 11 }, // 每行元素值表示这个任务由不同工人完成所需要的时间
                { 24, 18, 9, 6 },
                { 21, 1, 8, 28 }
                          };
        System.out.println("最小时间：" + getMin(cost, N));
    }


    private static int getMin(int[][] arr, int n) {
        int[] tAr = new int[n];
        int flag = 0;
        for (int i = 0; i < n; i++) {
            int min = arr[i][0] + tAr[0];
            flag = 0;
            for (int j = 0; j < n; j++) {
                if (min > (arr[i][j] + tAr[j])) {
                    // 找出本行可参与的最小值
                    min = (arr[i][j] + tAr[j]);
                    flag = j;
                }
            }
            tAr[flag] += arr[i][flag];
        }
        
        // 循环计算出最小时间
        int sum = 0;
        System.out.println("");
        for (int i = 0; i < tAr.length; i++) {
            System.out.print(tAr[i] + ", ");
            sum += tAr[i];
        }


        return sum;
    }


}



/**
 * 逆波兰表达式
 */
public class RPNExpresion {


    public static void main(String[] args) {
        String exp = "(1+25)*(322+7)";
        String[] strAr = getRPN(exp);
        System.out.print("逆波兰表达式为：");
        for (int i = strAr.length - 1; i >= 0; i--) {
            if (strAr[i] != null) {
                System.out.print(strAr[i] + " ");
            }
        }
    }


    private static String[] getRPN(String expr) {
        String flagStr = "+-*/";
        // 定义两个栈分别存储操作数和操作符
        Stack<String> numStack = new Stack<String>();
        Stack<String> oprStack = new Stack<String>();


        // 将字符串转换为字符串数组
        String[] strAr = getStrArr(expr);


        for (int i = 0; i < strAr.length; i++) {
            if (strAr[i] == null) {
                break;
            }
            //1、 如果是操作数，直接压入操作数栈中
            if (!flagStr.contains(strAr[i]) && !strAr[i].equals("(") && !strAr[i].equals(")")) {
                numStack.push(strAr[i]);
                continue;
            }
            //2、如果是“(”，直接压入操作符栈中
            if (strAr[i].equals("(")) {
                oprStack.push(strAr[i]);
                continue;
            }
            //2.1 如果是“)”，则从操作符栈中取数据，以此压入操作数栈中，直到遇到“(”
            if (strAr[i].equals(")")) {
                while (!oprStack.peek().equals("(")) {
                    numStack.push(oprStack.pop());
                }
                // 取走栈顶元素
                oprStack.pop();
                continue;
            }
            //3、 如果是操作符，则与操作符栈顶的操作符进行优先级比较
            if (flagStr.contains(strAr[i])) {
                if (oprStack.isEmpty()) {
                    oprStack.push(strAr[i]);
                    continue;
                }
                if (oprStack.peek().equals("(")) {
                    oprStack.push(strAr[i]);
                } else if (getPriority(strAr[i]) > getPriority(oprStack.peek())) {
                    oprStack.push(strAr[i]);
                } else {
                    numStack.push(oprStack.pop());
                    oprStack.push(strAr[i]);
                }
            }
        }
        // 对操作符栈进行最后判空处理
        while (!oprStack.empty() && (!oprStack.peek().equals("("))) {
            numStack.push(oprStack.pop());
        }
        String[] strArr2 = new String[strAr.length];
        int temIndex = 0;
        while (!numStack.isEmpty()) {
            strArr2[temIndex++] = numStack.pop();
        }
        return strArr2;
    }


    // 获取优先级函数
    private static int getPriority(String chs) {
        if (chs.equals("-") || chs.equals("+")) {
            return 1;
        } else if (chs.equals("*") || chs.equals("/")) {
            return 2;
        }else {
            return 3;
        }
    }


    // 将字符串转换为字符串数组
    private static String[] getStrArr(String str) {
        String[] strArr = new String[str.length()];
        int index = 0;
        int startIndex = 0;
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) < '0' || str.charAt(i) > '9') {
                strArr[index++] = str.substring(startIndex, i + 1);
                startIndex = i + 1;
                continue;
            } else {
                if (i < str.length() - 1 && (str.charAt(i + 1) < '0' || str.charAt(i + 1) > '9')) {
                    strArr[index++] = str.substring(startIndex, i + 1);
                    startIndex = i + 1;
                    continue;
                }
            }
        }
        // 对最后一个数做特殊判断处理
        if (str.charAt(str.length() - 1) >= '0' && str.charAt(str.length() - 1) <= '9') {
            strArr[index++] = str.substring(startIndex, str.length());
        }
        return strArr;
    }


}



/**
 * 筛子加和求概率
 */
public class SumOfShaiZi {


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


    private static void statistiSum(int n) {
        long[][] sum = new long[n + 1][6 * n + 1];
        for (int i = 1; i <= 6; i++) {
            sum[1][i] = 1;
        }
        if (n >= 2) {
            for (int i = 2; i <= n; i++) { // 表示有多少筛子
                for (int j = 1; j <= 6 * (i - 1); j++) { // 标记上个筛子的计数和最大值
                    for (int k = 1; k <= 6; k++) { // 对当下的筛子的1-6分别进行加数
                        sum[i][j + k] += sum[i - 1][(j)];
                    }
                }
            }
        }
        long sumCount = (long) Math.pow(6, n);
        DecimalFormat df = new DecimalFormat("0.00");
        System.out.println("共：" + sumCount);
        for (int i = n; i <= n * 6; i++) {
            double x = ((double) sum[n][i] / sumCount + 0.0);
            System.out.println("[" + sum[n][i] + "," + df.format(x) + "],");
        }
    }


}



/**
 * 任务调度，求最短时间
 */
public class TaskScheduling {


    public static void main(String[] args) {
        int[] t = { 5, 2, 2, 9, 4 };
        int n = 10;
        System.out.println(getMinTime(t, n));
    }


    public static int getMinTime(int[] t, int n) {
        int len = t.length;
        // 1. 只有一台执行机时
        if (len == 1) {
            return (t[0] * n);
        }


        // 2.1 初始化一份临时数组
        int[] temTi = new int[len];
        for (int i = 0; i < len; i++) {
            temTi[i] = 0;
        }
        // 2.2 循环进行计算最小加和
        int temMin = 0;
        for (int i = 0; i < n; i++) {
            temMin = temTi[0] + t[0];
            int index = 0;
            for (int k = 1; k < len; k++) {
                if (temMin > (temTi[k] + t[k])) {
                    temMin = (temTi[k] + t[k]);
                    index = k;
                }
            }
            temTi[index] += t[index];
        }


        return temMin;
    }


}

ACM8615~ACM8629-AudioTuningSetup-1.4.2-20240228
06-13
在本次分析的文件信息中，我们关注的是一个特定版本的上位机软件——ACM8615~ACM8629-AudioTuningSetup-1.4.2-20240228。此软件版本是针对ACM86xx系列数字功放设备进行音频调整与优化的专用工具。数字功放以其高效率...
ACM考试题 ACM程序设计
04-07
### ACM程序设计基础知识点 #### 一、ACM竞赛概览 - **组织机构与活动**: 本课程由东北林业大学陈宇老师负责，通过邮箱Lg_chenyu@yahoo.com.cn进行联系。课程的主要目的是介绍ACM程序设计的基础概念及入门技巧。 - ...
精选优快云的ACM-ICPC五星博客
weixin_34232617的博客
08-05 125
海岛Blog - 博客频道 - 优快云.NETACM！荣耀之路！ - 博客频道 - 优快云.NETACdreamer - 博客频道 - 优快云.NET笑着走完自己的路 - 博客频道 - 优快云.NET窝不是爱酱,喵~~~~ - 博客频道 - 优快云.NET小白菜又菜 - 博客频道 - 优快云.NET飘过的小牛 - 博客频道 - 优快云.NETyan...
不要62 ACM 优快云 简单的数位dp题
Sunshine_H的帅气博客
04-09 291
** 不要62 ** 杭州人称那些傻乎乎粘嗒嗒的人为62（音：laoer）。 杭州交通管理局经常会扩充一些的士车牌照，新近出来一个好消息，以后上牌照，不再含有不吉利的数字了，这样一来，就可以消除个别的士司机和乘客的心理障碍，更安全地服务大众。 不吉利的数字为所有含有4或62的号码。例如： 62315 73418 88914 都属于不吉利号码。但是，61152虽然含有6和2，但不是62连号，所以不属...
acm入门
free斩
11-16 3110
初期: 一.基本算法:      (1)枚举. (poj1753,poj2965)      (2)贪心(poj1328,poj2109,poj2586)      (3)递归和分治法.      (4)递推.      (5)构造法.(poj3295)      (6)模拟法.(poj1068,poj2632,poj1573,poj2993,poj2996) 二.图算法:
关于acm
我们都在不断努力
02-28 575
严谨说明：该分类的学习大部分为通过  刘汝佳的算法竞赛入门经典的一个学习过程，首先说明，博客分类之中确实很难找出合适的词形容这一分类文章的出处，为尊重原创作者，在此必须先大师刘汝佳致敬，定为原创在于这是一个学习的过程，不是一个创造的过程，并非学术性质的探索，亲自敲写代码后加入很多自己的感受和心得，故分类原创，望大家理解，其次和大家一起学习学习。
ACM之路
最有趣的编程
09-19 654
ACM之路 时间限制：1000 ms  |  内存限制：65535 KB 难度：0 描述 转眼间，12级新生已经学习C语言一个多月，又要有很多人踏上 AC 之路了。 就让下面这道题为大家开启 ACM 的大门吧。 输入只有一组测试数据。 输入一个整数N。 输出输出N行。 每行输出"I Love Acm."。（不输出引号） 样例输入 2
ACM题集-ACM训练题集-超多ACM题集汇总-解题源码
01-17
这个压缩包文件“ACM题集_ACM训练题集_超多ACM题集汇总_解题源码”显然是一个集合，包含了大量ACM竞赛相关的题目和已经解决的源代码，对于学习和准备ACM比赛的学员来说是宝贵的资源。 在ACM竞赛中，参赛队伍需要...
cdc-acm.rar_CDC-ACM_V2 _cdc acm
09-24
标题中的"CDC-ACM.rar_CDC-ACM_V2 _cdc acm"指的是一个针对Linux操作系统的USB抽象控制模型（CDC-ACM）驱动程序的更新版本V2.13.6。这个驱动程序专门用于支持USB调制解调器和ISDN适配器，使得这些设备能够在Linux...
基于C++实现的ACM-ACM竞赛常用模板
03-22
在ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest）中，参赛团队需要使用编程语言解决一系列算法问题。C++作为一门强大的编程语言，因其高效、灵活性和丰富的库支持，成为了ACM竞赛中...
ACM资料合集
03-24
ACM的资源合集,你不需要到处去找了! （lecture_01）初识ACM090216 （lecture_02）简单数学题090929 （lecture_03）递推求解090302 （lecture_04）动态规划(1)_20091019 （lecture_05）计算几何基础_20091027 （lecture_06）母函数091103 （lecture_07）特殊的数 （lecture_08）组合博弈入门 （lecture_09）贪心算法090420 （lecture_11）搜索入门081210 （lecture_12）二分匹配及其应用 （lecture_13）动态规划(2) [挑战程序设计竞赛(第2版)].巫泽俊.扫描版 acm_常用的数学公式 ACM程序设计竞赛基础教程_俞经善等编 ACM算法集锦(实现代码) C和C++代码精粹 STL_in_ACM 吉大ACM模板 浙江大学ACM模板(经典代码） 算法竞赛入门经典（第2版） -刘汝佳 挑战程序设计竞赛（第2版）完整扫描版 浙师大acm教材 等.....
ACM(绝对经典)
10-25
ACM (Association for Computing Machinery ) 中文：国际计算机学会。ACM是一个世界性的计算机从业员专业组织，创立于1947年，是世界上第一个科学性及教育性计算机学会，目前在全世界130多个国家和地区拥有超过10万名的会员。ACM是全世界计算机领域影响力最大的专业学术组织。ACM所评选的图灵奖（A.M. Turing Award）被公认为世界计算机领域的诺贝尔奖。现任主席为Vicki L. Hanson教授。
acm
最新发布
08-26
Association for Computing Machinery (ACM) 是全球计算机领域最具影响力的学术组织之一，其官方网站和资源为研究人员、教育工作者、学生以及行业专业人士提供了丰富的学术内容和专业支持。ACM 的官方网站是 [https://www.acm.org](https://www.acm.org)，该网站集成了多种服务和资源，包括数字图书馆、期刊、会议、教育项目以及职业发展工具。 ### ACM 官方网站主要资源 1. **ACM Digital Library（ACM 数字图书馆）** ACM Digital Library 是一个全面的在线资源库，收录了 ACM 发布的所有期刊、会议录、技术通讯以及特别报告。用户可以通过关键词、作者、出版年份等方式进行检索[^1]。 2. **ACM 期刊与会议录** ACM 出版多个高影响力的同行评审期刊，包括： - *Journal of the ACM (JACM)*：世界计算机科学领域的顶级期刊之一，专注于理论计算机科学、算法、复杂性分析等方向。 - *ACM Transactions* 系列：涵盖多个子领域，如数据库系统（TODS）、计算机系统（TCS）、图形学（TOG）等。 3. **ACM Conferences（ACM 会议）** ACM 主办多个国际顶级会议，如： - *ACM SIGMOD Conference*：数据库领域的旗舰会议。 - *ACM Symposium on Theory of Computing (STOC)*：理论计算机科学领域的重要会议。 - *ACM International Conference on Multimedia (MM)*：多媒体技术领域的权威会议。 4. **ACM Special Interest Groups (SIGs)** ACM 下设多个专业兴趣小组（SIGs），每个 SIG 专注于特定的计算机科学分支，例如： - *SIGMOD*：数据管理 - *SIGGRAPH*：计算机图形学 - *SIGCOMM*：网络与通信 - *SIGCHI*：人机交互 5. **ACM Learning & Career Development** ACM 提供职业发展资源，包括在线课程、Webinar、职业中心、教育计划等，帮助会员提升技能并拓展职业网络。 6. **ACM Code of Ethics and Professional Conduct** ACM 制定了《ACM 道德与职业行为准则》，为全球计算机专业人员提供道德指导，涵盖隐私保护、知识产权、社会责任等方面。 ### 示例：访问 ACM Digital Library 的方式 用户可以通过以下代码片段使用 Python 爬取 ACM 数字图书馆中某期刊的最新目录（需遵守网站的访问政策）： ```python import requests from bs4 import BeautifulSoup url = 'https://dl.acm.org/toc/jacm/70/4' headers = {'User-Agent': 'Mozilla/5.0'} response = requests.get(url, headers=headers) soup = BeautifulSoup(response.text, 'html.parser') articles = soup.find_all('h5', class_='issue-item__title') for article in articles: print(article.text.strip()) ``` ###
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值