zoukankan      html  css  js  c++  java
  • B. 简单的问题

    B. 简单的问题

    1000ms
    1000ms
    65536KB
     
    64-bit integer IO format: %lld      Java class name: Main
    Font Size:
    算法的渐进时间复杂度是算法的运行时间的一种度量方式,通常用运行时间随输入规模的增长而增长的速率来表示。
    时间复杂度是评估一个算法的重要参考标准。
    比如常见的冒泡排序和选择排序,时间复杂度是O(n^2),而快速排序、归并排序的时间复杂度是O(nlogn)。这两类算法在实现的时候,其运行时间随着数据规模的增长而增长的速率不同。一般来说到n=10000的规模的时候两类算法的运行时间就会有显著差异。
    下面有一个程序:
    -----------------------------------------------
    #include<stdio.h>
    int main()
    {
       int n,a[10001];
       int T;
       int i,j,k;
       int ans=0;
       scanf("%d",&T);
       while(T--)
       {
           scanf("%d",&n);
           ans=0;
           for(i=0;i<n;++i)
               scanf("%d",&a[i]);
           for(i=0;i<n;++i)
               for(j=0;j<n;++j)
                   ans+=(a[i]|a[j]);
           printf("%d ",ans);
       }
    return 0;
    }
    -----------------------------------------------
    上面这个程序的时间复杂度就是O(n^2)的,输入规模增长到原来的n倍,运行时间将会是原来的n^2倍(两重循环内部的操作的次数变为原来的n^2倍)。这样的程序对于n高达10000的数据规模运行时间显然太长了,无法达到我们的要求。所以请你帮忙修改一下这个程序(只是两重循环的部分),降低算法的时间复杂度,但是程序的功能不能改变。
     

    Input

    测试数据有多组,第一行给出了测试数据的组数T(T<100)
    每组数据的第一行有一个正整数 n (1≤n≤10000)。
    接下来同一行有n个非负整数,每个数都不超过 2^16范围。两个数之间用空格分开。

     

    Output

    输出有T行,每行为一个非负整数,为每组输入数据的对应输出,结果不会超出32位整数的范围。
     

    Sample Input

    1
    2 18467 6334
    
    
     

    Sample Output

    70239
    #include<iostream>
    #include<stdio.h>
    #include<string.h>
    using namespace std;
    struct node
    {
        int a[20];
        int cnt;
        int num;
    } s[10005];
    int t[20],f=0;
    int p[20]= {1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072};
    int main()
    {
        int text;
        scanf("%d",&text);
        while(text--)
        {
            memset(s,0,sizeof(s));
            memset(t,0,sizeof(t));
            int n;
            scanf("%d",&n);
            for(int i=1; i<=n; i++)
            {
                scanf("%d",&s[i].num);
                int tmp=s[i].num;
                while(tmp>0)
                {
                    int tmp1=s[i].cnt;
                    s[i].a[tmp1]=tmp%2;
                    tmp/=2;
                    s[i].cnt++;
                }
                for(int j=0; j<=15; j++)
                    if(s[i].a[j]==1)
                        t[j]++;
            }
            int ans=0;
            for(int i=1; i<=n; i++)
            {
                for(int j=0; j<=15; j++)
                {
                    if(s[i].a[j]==1)
                    {
                        ans+=p[j]*n;
                    }
                    if(s[i].a[j]==0)
                    {
                        ans+=t[j]*p[j];
                    }
                }
            }
            printf("%d ",ans);
        }
        return 0;
    }
  • 相关阅读:
    leetcode 1036. 逃离大迷宫(bfs)
    leetcode 1040. 移动石子直到连续 II(滑动窗口)
    leetcode 1039. 多边形三角剖分的最低得分(区间dp)
    Han Xin and His Troops(扩展中国剩余定理 Python版)
    CCPC 2019 网络赛 HDU huntian oy (杜教筛)
    多项式模板
    树链剖分(模板) 洛谷P3384
    2019牛客暑期多校训练营(第九场)
    CF #575 Div3
    计算几何模板集
  • 原文地址:https://www.cnblogs.com/lxm940130740/p/3332208.html
Copyright © 2011-2022 走看看