精华内容
下载资源
问答
  • 倒序规律

    2018-12-18 16:53:05
    倒序规律

    题意:

    样例配图如下:求长度

    样例输入

    3

    1 4

    4 1

    3 3

    样例输出

    10

    # include <bits/stdc++.h>
    
    # define pp make_pair
    
    using namespace std;
    
    typedef long long LL;
    
    const int maxn = 1e5+30;
    
    int x[maxn], y[maxn];
    
    set<pair<int,int> >s, t;
    
    int main(){
    
        int n;
    
        scanf("%d",&n);
    
        for(int i=1; i<=n; ++i){
    
            scanf("%d%d",&x[i],&y[i]);
    
        }
    
        LL ans = 0;
    
        for(int i=n; i>=1; --i){
    
            auto it = s.lower_bound({x[i], 0});
    
            if(it == s.end()) ans+= y[i];
    
            else ans += y[i]-it->second;
    
            s.insert({x[i], y[i]});
    
            it = t.lower_bound({y[i], 0});
    
            if(it == t.end()) ans += x[i];
    
            else ans += x[i]-it->second;
    
            t.insert({y[i], x[i]});
    
    
    
        }
    
        printf("%lld\n",ans);
    
        return 0;
    
    }

    个人思想:

    开一个SET,先把(0,INF)(INF,0)打进去,然后把输入的点按倒序依次压入SET,ANS每次加上离左边第一个点的X坐标差值,再加上离右边第一个点的Y坐标差值

    展开全文
  • 倒序数

    千次阅读 2017-10-04 19:12:24
    倒序数 时间限制: 1000 ms 内存限制: 65536 KB 提交数: 392 通过数: 297  【题目描述】 输入一个非负整数,输出这个数的倒序数。例如输入123,输出321。 【输入】 输入一个非负整数(保证个位不为零)。...

    倒序数


    时间限制: 1000 ms         内存限制: 65536 KB
    提交数: 392     通过数: 297 

    【题目描述】

    输入一个非负整数,输出这个数的倒序数。例如输入123,输出321。

    【输入】

    输入一个非负整数(保证个位不为零)。

    【输出】

    输出倒序的数。

    【输入样例】

    123

    【输出样例】

    321

    【来源】


    No

    【代码】

    #include 
    #include 
    #include     
    using namespace std;
    int main()  
    {
    	int n,a[2000],i=0;
    	cin>>n;
    	while(n!=0)//倒序输出
    	{
    		a[i]=n%10;
    		cout<

    【说明】

    vc6.0运行成功,提交通过



    展开全文
  • 相加 题目: 我的解法: /** * @Description TODO * @Param [l1, l2] * @return arrays.addTwoNumbers.ListNode * @date 2020/7/14 17:21 * @author huanl * * 思路:先把他全部拿出来,拿出来的时候用字符...

    两数相加

    题目:

    image-20200714180708553

    我的解法:

     /**
       * @Description TODO
       * @Param [l1, l2]
       * @return arrays.addTwoNumbers.ListNode
       * @date 2020/7/14 17:21
       * @author huanl
       *
       * 思路:先把他全部拿出来,拿出来的时候用字符串的append函数连接起来,后面再用reverse去反转.在把他们相加的到的
       * 数转换为StringBuilder类型,然后反转,然后在把他变成ListNode类型.
       *
       * 问题: 为什么要全部拿出来? 我们正常时候做加法,不就是从低位做起,然后有进位就记录一下,下一次添加上.现在链表他给我们就是已经弄好了的低位,
       * 直接从低位开始相加就好了.
       *        直接一个一个取然后加的话怎么判断他本身到底有没有值?  噢,直接判断这个节点是不是为null
       *        加到最后可能最后一次的进位记录为一,怎么处理?   再在后面多加一个节点,将这个一记录上去.
       */
        public  ListNode addTwoNumber(ListNode l1, ListNode l2) {
            
            //用StringBuilder取出l1和l2里面所有的
            StringBuilder num1 = new StringBuilder();
            StringBuilder num2 = new StringBuilder();
            num1.append(l1.val);
            num2.append(l2.val);
            while (l1.next != null) {
                num1.append(l1.next.val);
                l1 = l1.next;
            }
            while (l2.next != null) {
                num2.append(l2.next.val);
                l2 = l2.next;
            }
            //反转为正常的顺序
            num1 = num1.reverse();
            num2 = num2.reverse();
    
            //将两个字符串相加 (因为直接一次的话会超出int或者long的长度) 其实最好就是将他们逆转过来,这样才符合我们日常的加法
            int[] nums = new int[(Math.max(num1.length(), num2.length())) + 1];
            for (int i = 1; i <= (Math.max(num1.length(), num2.length())); i++) {
                if (i>num1.length()){
                    nums[nums.length-i] = Integer.parseInt(String.valueOf(num2.charAt(num2.length()-i)));
                }else if(i>num2.length()){
                    nums[nums.length-i] = Integer.parseInt(String.valueOf(num1.charAt(num1.length()-i)));
                }else {
                    nums[nums.length-i] = Integer.parseInt(String.valueOf(num1.charAt(num1.length()-i))) + Integer.parseInt(String.valueOf(num2.charAt(num2.length()-i)));
                }
    
            }
    
            //处理进位信息
            for (int i = nums.length - 1; i > 0; i--) {
                nums[i-1] = nums[i-1] + nums[i] / 10;
                nums[i] = nums[i] % 10;
            }
    
            //因为两数相加可能会多一位,也就是第一位可能为1,可能为0,这里就先不处理第一位,直接从第二位开始处理
            StringBuilder num = new StringBuilder();
            for (int i = 1; i < nums.length ; i++) {
                num.append(nums[i]);
            }
            //处理第一位,如果为一,则直接插入最前面
            if (nums[0] != 0) {
                num.insert(0,nums[0]);
            }
            num = num.reverse();
    
            //将字符串类型的转化为ListNode类型
            ListNode ret = new ListNode(num.charAt(0) - 48);
    
            ListNode jilu = ret;
    
            for (int i = 1; i < num.length(); i++) {
                jilu.next = new ListNode(num.charAt(i) - 48);
                jilu = jilu.next;
        }
            return ret;
    
            }
    

    问题:

    1. 为什么要先全部取出来? 有什么好处? 还是不能直接一个一个操作?

    2. 正是因为想要全部取出来,然后StringBuilder类型拼接快,然后StringBuilder又有一个反转函数,所以去用了StringBuilder,然后反转之后,本来想要用Integer.parseInt()转化为int然后相加,但是发现这个太容易直接超出范围,所以不得不直接用StringBuilder类型的直接相加,并且还用了反转之后的来相加,这就导致了相加函数复杂,并且相加之后,还需要处理进位信息,处理有没有多了一位的信息.

    3. 总结:

      1. 第一步的思路就问题,导致后续麻烦不断的到来,那为什么我会想取直接把他全部取出来呢?  
      	     没有取过多的考虑全部取出来有什么麻烦,就是简单就直接去取出来
      2. 能够去写出不定长字符串的加法,这个值得鼓励.
      

    优解:

         /**
             * @Description TODO
             * @Param [l1, l2]
             * @return arrays.addTwoNumbers.ListNode
             * @date 2020/7/14 17:08
             * @author huanl
             */
        public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
            ListNode dummyHead = new ListNode(0);
            ListNode p = l1, q = l2, curr = dummyHead;
            int carry = 0;
            while (p != null || q != null) {
                int x = (p != null) ? p.val : 0;
                int y = (q != null) ? q.val : 0;
                int sum = carry + x + y;
                carry = sum / 10;
                curr.next = new ListNode(sum % 10);
                curr = curr.next;
                if (p != null) p = p.next;
                if (q != null) q = q.next;
            }
            if (carry > 0) {
                curr.next = new ListNode(carry);
            }
            return dummyHead.next;
        }
    

    优点:

    1. 一个一个取,取出来直接进行操作,该进位的直接将进位符标志为1.
    	为什么要一个一个取? 
    		因为他给我们的就是符合加法计算规律的,也就是先从低位算起,有进位加到高位,并且链表取值的方向也正好是从低位到高位,各种条件都非常适合直接加.
    2. 注意细节:
    	a. 先建造一个头节点,这个头节点里面的值不和任何有关,那为什么要建一个这样的头节点呢? 因为没有这个头节点,第一次加法的时候就没有链表去操作,那么就势必需要把第一次提出来先做,这样就感觉有点不统一了.
    	b. 用另外一个指针去操作,因为你需要返回这个链表,那么这个链表的头指针你必须保存一个,不然你就找不到这个指针了.
    	c. 注意判断此时值到底取val还是0,判断条件是什么?  直接判断这个节点是不是空节点,因为我们操作的就是此节点,不是next节点.
    	d. 注意可能最后一次加法时,进位为一,那么则需要在给他最后再加上一个节点,例如999+1就可能得到4位,这样就需要多加一个节点.
    

    经验

    1. 先想一下怎么做,然后确定觉得这样做可以之后,把详细的思路写一遍,想一想为什么每一步需要这样做?和实际的相符吗?
      节点.
      d. 注意可能最后一次加法时,进位为一,那么则需要在给他最后再加上一个节点,例如999+1就可能得到4位,这样就需要多加一个节点.
    
    ## 经验
    
    1. 先想一下怎么做,然后确定觉得这样做可以之后,把详细的思路写一遍,想一想为什么每一步需要这样做?和实际的相符吗?
    2. 不定长字符串的加法,每位保存一个值的算法.
    
    展开全文
  • 整数倒序显示

    2020-03-09 17:58:54
    想要将一个整数进行倒序显示,我们首先观察规律可以发现原来数字的最高位变成了现在数字的最低位,中间位数的顺序也在相应的发生改变,因此,想要完成这个任务我们首先就应该把这个整数的各个位分离出来,然后重新...

    问题:
    程序每次读入一个正3位数,然后输出按位逆序的数字。注意:当输入的数字含有结尾的0时,输出不应带有前导的0。比如输入700,输出应该是7。
    问题分析:
    想要将一个整数进行倒序显示,我们首先观察规律可以发现原来数字的最高位变成了现在数字的最低位,中间位数的顺序也在相应的发生改变,因此,想要完成这个任务我们首先就应该把这个整数的各个位分离出来,然后重新组合。
    问题解决
    假如我们输入的数为123,那么它的个位为3、十位为2、百位为1,要怎么计算出来呢?这就体现了计算思维!
    1.个位3=123%10(%为取模);
    2. 十位2=123/10%10;
    3. 百位1=123/10/10%10
    接下来要做的就是将它们重新组装回去。
    321=3100+210+1;
    因此,将它转化成程序语言就是:

    #include<stdio.h>
    int main(void)
    {
    	int num,newnum,ge,shi,bai;
    	printf("请输入一个正整数:");
    	scanf("%d",&num);
    	bit=num%10;//分离出个位
    	tenth=num/10%10;//分离出十位
    	percent  =num/100%10;//分离出百位
    	newnum=ge*100+shi*10+1;//重新组合
    	printf("%d倒序之后为%d",num,newnum);
    	return 0;
    	}	
    

    除此之外我们还可以用循环结构来解决这个问题:

    #include<stdio.h>
    int main(void)
    {
    	int num;//输入的数
    	int bit;//个位数字
    	int newnum;//倒序后的数
    	int value;
    	printf("请输入一个正整数:");
            scanf("%d",&num)
    	value=num;
    	newnum=0;
    	while(num!=0)
    	{
    	   bit=num%10;
    	   newnum=newnum*10+bit;
    	   num/=10;
     	}
            printf("%d倒序之后为%d",value,newnum);
            return 0;	
    }
    
    展开全文
  • 倒序索引

    千次阅读 2018-10-11 08:42:55
    * 并不是所有job都适用于Combiner,只有操作满足结合规律才可以进行设置 * 如 求和,求最大值,topN 等可以使用Combiner * * Combiner不一定需要存在,只有数据量较大,需要做优化的时候可以使用 ...
  • FFT中的倒序算法的改进,张欢,郑小冬,在原变址运算的基础上,进一步挖掘在“倒序位”过程中所隐藏的规律,直接利用倒序数以后的数据中所体现的规律进行编程,而不用再
  • 1.案例要求:"""有列表["a", "d", ...根据逻辑找规律,确定数据替换进行的次数,元素个为奇数和偶数需要注意。(2).交换数据的双方,索引不同,其中一个由小到大,另一个由大到小。list1 = ["a", "d", "f", "j","...
  • C 递归和倒序计算

    2016-10-03 21:53:11
    递归在处理倒序时非常方便,在下面的问题中,使用递归比循环简单。我们要解决的问题是,编写一个函数,打印一个整数的二进制。在二进制中,奇数的末尾一定是1,偶数的末尾一定是0,利用5%2即可确定5的二进制的...
  • 将一个数倒序有几种方法。我们先从简单的开始。 实例1 有几位数就声明几个变量,要倒序时,直接改变变量的顺序即可 1 # include <stdio.h> // 调用标准输入/输出库<stdio.h> 2 3 int main...
  • 倒序输出杨辉三角

    千次阅读 2018-01-04 23:41:35
    2.然后倒着输出,找到倒着输出的规律就好了。记得数字的占位符的宽度应该和一次输出的空格的长度相等。 #include #include using namespace std ; int main() { int n; int a[ 10 ][ 10 ]={ 0 }...
  • 根据逻辑找规律,确定数据替换进行的次数,元素个为奇数和偶数需要注意。 (2).交换数据的双方,索引不同,其中一个由小到大,另一个由大到小。 list1 = [a, d, f, j,z,Z,1] # 方法一: x = len(list1) # 计算...
  • python对列表中的元素进行倒序打印

    千次阅读 2019-03-09 23:52:50
    1.案例要求: &quot;&quot;&quot;有列表[&quot;a&quot;, &quot;d&quot;, &quot;f&...],对列表进行倒序,打印结果为[&quot;1&quot;,&quot;Z&quo
  • 递归在处理倒序时非常方便 (在解决这类问题中,递归比循环简单) 我们要解决的问题是:编写一个函数,打印一个整数的二进制, 二进制表示法根据 2 的幂来表示数字 例如,十进制 234 实际上是 2×102+3×101+4×...
  • 题意:输入一个长度为 小于100的,判断这个和这个倒序被 9 整除后的中 的数字是不是都相同; 思路:通常大家想法一定和我一样 把过程模拟一边就行了呗,但是这其中是有规律可询的,找到规律,你将受益无穷...
  • 使用数组方法使得图文顺序倒序随机切换 实现功能描述:从小到大 和从大到小是同一个按钮,切换图片和文字;随机排序是另一个按钮,可以随机切换图文。 第一种方法:使用了数组的sort函数排序,随机数用的是Math....
  • 其实属于小学找规律的题 50 } 51 return final_num; 52 } 上面的算法可以达到目的,备注也比较清晰了,但这属于基础级。 我们要翻转,首先要数据分离,求得输入数字的位数,求输入数字位数就是一个...
  • 1.案例要求:"""有列表["a", "d", ...根据逻辑找规律,确定数据替换进行的次数,元素个为奇数和偶数需要注意。(2).交换数据的双方,索引不同,其中一个由小到大,另一个由大到小。list1 = ["a", "d", "f", "j","...
  • //利用函数给n个数字倒序 #include<stdio.h> paixu(int x[],int n) //数组的第一个数字为0,最后一个数字为n-1 //第二个数字为1,倒数第二个数字为n-2 {int t,i,m=(n-1)/2; //m为执行的次数,找规律的 for...
  • 现输入一个,要求按原来的规律将它插入数组中。 #!/usr/bin/python 3 # -*- coding: UTF-8 -*- #两种方法 _Author_ = '麦地吃大米' #print(list1) def sort1(ls): ls.sort()#正序,倒序可以加个reverse ...
  • 这是正序的杨辉三角,每一行之间的规律都是一样的左边的只是多了空格而已,下面直接上正序代码: public static void main(String[] args) { Scanner sc=new Scanner(System.in); int n=sc.nextInt(); ...
  • 回文是指正序(从左向右)和倒序(从右向左)读都是一样的整数。 看到题目的第一反应是将int转化成String然后再判断是否是回文。 仔细思考一下之后,发现数字的反转也是有规律可循的,根本不需要转化成字符串。...
  • 输入一个整数,倒序输出 出题目的 该题目目的是让初学者能够在实际运用中使用数学思维去解决问题,能够通过这道题目去逐步掌握要解答这道题目需要掌握的知识点及相关技能,然后通过一步一步分析解题思路,最终...
  • 第一个程序:有bug,但没发现 ...现输入一个,要求按原来的规律将它插入数组中。 1. 程序分析:首先判断此是否大于最后一个,然后再考虑插入中间的的情况, 插入后此元素之后的,依次后移一个位置
  • 现输入一个,要求按原来的规律将它插入数组中。代码如下:package com.homework.lhh;import java.util.Arrays; import java.util.Scanner;public class Ex13 { @SuppressWarnings("resource") public static ...
  • 案例 : 统计每个用户(手机号)的总上行流量、下行流量 , 总流量 , 并按总流量倒序排序 案例数据: 1363157985066 13726230503 00-FD-07-A4-72-B8:CMCC 120.196.100.82 i02.c.aliimg.com 24 27 2481 24681 200 ...
  • 直接插入排序算法: ...如果他比前面的小,就把那个前面的像后移动一位,这样每次发现一个小的都向后移动一位,最后把这个插入到最后移动的那个地方。 3.我原来的思路是正向从已经排序好的进行查找

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,017
精华内容 1,606
关键字:

倒序数规律