某模拟题题解 2016.11.17

---

　　第一题并不是很难，首先筛出1 ~ sqrt(r)中的所有质数，然后用再用筛法直接筛[l, r]中的质数。筛出来找一遍就行了。

Code

#include<iostream>
#include<cstdio>
#include<cctype>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<sstream>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<vector>
#include<stack>
using namespace std;
typedef bool boolean;
#define INF 0xfffffff
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)
template<typename T>
inline void readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-');
    if(x == '-'){
        x = getchar();
        aFlag = -1;
    }
    for(u = x - '0'; isdigit((x = getchar())); u = (u << 1) + (u << 3) + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
}

long long l, r;
boolean isPrime[1000001];
vector<int> p;

inline void init(){
    readInteger(l);
    readInteger(r);
}

inline void getList(){
    int limit = (int)sqrt(r + 0.5);
    for(int i = 2; i <= limit; i++){
        if(!isPrime[i]){
            p.push_back(i);
            for(int j = i * i; j <= limit; j += i){
                isPrime[j] = true;
            }
        }
    }
}

inline void solve(){
    int result = 0;
    memset(isPrime, 0, sizeof(isPrime));
    for(int i = 0; i < (signed)p.size(); i++){
        int pri = p[i];
        int bot = l / pri;
        for(int j = bot; j * 1LL * pri <= r; j++){
            long long val = j * 1LL * pri;
            if(val >= l && val != pri){
                isPrime[val - l] = true;
            }
        }
    }
    for(int i = 0; i <= r - l; i++){
        if(!isPrime[i] && i + l != 1)    result++;
    }
    printf("%d", result);
}

int main(){
    freopen("prime.in", "r", stdin);
    freopen("prime.out", "w", stdout);
    init();
    getList();
    solve();
    return 0;
}

---

---

　　这道题就是道计算题(呵呵)。可以直接算出当n = 9, 99， 999...的情况。那么就可以从高位向低位计算。举个例子应该更好说明。
　　例如n = 1234的时候，首位3,那么1到1000时的各位数字之和为1 * sum₃ + (234 + 1) * 1 + 1 * 10³，1001到1200的各位数字之和为2 * sum₂ + (34 + 1) * 2 + (1 + 2) * 10²，大概就是像这样的，继续算下去，然后累加起来就是答案。
　　关于sum的递推式还是写一下吧sum_i = sum_{i - 1} * 10 + 45 * 10^{i - 1}。

Code

#include<iostream>
#include<cstdio>
#include<cctype>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<sstream>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<vector>
#include<stack>
using namespace std;
typedef bool boolean;
#define INF 0xfffffff
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)
template<typename T>
inline void readInteger(T& u){
    char x;
    long long aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-');
    if(x == '-'){
        x = getchar();
        aFlag = -1;
    }
    for(u = x - '0'; isdigit((x = getchar())); u = (u << 1) + (u << 3) + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
}

template<typename T>
inline void putInteger(T u){
    if(u == 0){
        putchar('0');
        return;
    }
    if(u < 0){
        putchar('-');
        u *= -1;
    }
    stack<char>    s;
    while(u != 0)    s.push(u % 10 + '0'), u /= 10;
    while(!s.empty())    putchar(s.top()), s.pop();
}

long long n;
long long rn;
long long bit;
long long power[10] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};

inline void init(){
    readInteger(n);
    long long c = n;
    queue<long long> s;
    while(c != 0)    s.push(c % 10), c /= 10;
    while(!s.empty())
        rn *= 10, rn += s.front(), s.pop(), bit++;
}

long long sum[10];
inline void getList(){
    sum[0] = 0;
    for(long long i = 1; i <= 9; i++)
        sum[i] = sum[i - 1] * 10 + 45LL * power[i - 1];
}
    
inline void solve(){
    long long result = 0;
    while(rn != 0){
        long long f = rn % 10;
        result += f * (n % power[bit - 1] + 1) + f * (f - 1) / 2 * power[bit - 1];
        result += f * sum[bit - 1];
        rn /= 10, bit--;
    }
    putInteger(result);
}

int main(){
    freopen("count.in", "r", stdin);
    freopen("count.out", "w", stdout);
    init();
    getList();
    solve();
    return 0;
}

---

---

　　这题正解线段树 + 扫描线。

　　首先说说按列处理。车按照横坐标排序，矩形按照纵坐标排序，从1到n开始扫描。

• 当扫描到一个车，加入按照纵坐标建的线段树，直接将对应点的值改为它的横坐标
• 当扫描到某一个矩形的右边那条边，在线段树中查找[y1, y2]的区间最小值，当找到的结果小于x1，则说明存在一行不存在车

　　然后再按行处理一次，思路几乎是一样的。至于判定， 如果两次扫描都不是完全覆盖， 那么输出NO，否则输出YES

Code

#include<iostream>
#include<cstdio>
#include<cctype>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<sstream>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<vector>
#include<stack>
using namespace std;
typedef bool boolean;
#define INF 0xfffffff
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)
template<typename T>
inline void readInteger(T& u){
    char x;
    long long aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-');
    if(x == '-'){
        x = getchar();
        aFlag = -1;
    }
    for(u = x - '0'; isdigit((x = getchar())); u = (u << 1) + (u << 3) + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
}

typedef class TreeNode{
    public:
        int from;
        int end;
        TreeNode* left;
        TreeNode* right;
        int minv;
        TreeNode(int from, int end):from(from), end(end), left(NULL), right(NULL), minv(-1){    }
}TreeNode;

typedef class SegTree {
    public:
        TreeNode* root;
        SegTree():root(NULL){    }
        SegTree(int s){
            build(root, 1, s);
        }
        void pushUp(TreeNode* node){
            node->minv = min(node->left->minv, node->right->minv);
        }
        void build(TreeNode* &node, int l, int r){
            node = new TreeNode(l, r);
            if(l == r)    return;
            int mid = (l + r) >> 1;
            build(node->left, l, mid);
            build(node->right, mid + 1, r);
        }
        void update(TreeNode* node, int d, int val){
            if(node->from == d && node->end == d){
                node->minv = val;
                return;
            }
            int mid = (node->from + node->end) >> 1;
            if(d <= mid)    update(node->left, d, val);
            else update(node->right, d, val);
            pushUp(node);
        }
        int query(TreeNode* node, int l, int r){
            if(node->from == l && node->end == r){
                return node->minv;
            }
            int mid = (node->from + node->end) >> 1;
            if(l > mid)        return query(node->right, l, r);
            else if(r <= mid)    return query(node->left, l, r);
            else    return min(query(node->left, l, mid), 
                        query(node->right, mid + 1, r));
        }
        void clean(TreeNode* node){
            if(node == NULL)    return;
            clean(node->left);
            clean(node->right);
            delete node;
        } 
}SegTree;

typedef class Point {
    public:
        int x;
        int y;
        Point(const int x = 0, const int y = 0):x(x), y(y){        }
}Point;

typedef class Rect {
    public:
        int x1, x2;
        int y1, y2;
        int id;
        Rect(const int x1 = 0, const int y1 = 0, const int x2 = 0, const int y2 = 0):x1(x1), y1(y1), x2(x2), y2(y2), id(0){}
}Rect;

int n, m, k, q;
SegTree lines;
SegTree rows;
Rect* rs;
Point* ps;

boolean cmpp1(const Point& a, const Point& b){
    if(a.x != b.x)    return a.x < b.x;
    return a.y < b.y;    
}

boolean cmpp2(const Point& a, const Point& b){
    if(a.y != b.y)    return a.y < b.y;
    return a.x < b.x;
}

boolean cmpr1(const Rect& a, const Rect& b){
    return a.x2 < b.x2;
}

boolean cmpr2(const Rect& a, const Rect& b){
    return a.y2 < b.y2;
}

inline void init(){
    readInteger(n);
    readInteger(m);
    readInteger(k);
    readInteger(q);
    ps = new Point[(const int)(k + 1)];
    rs = new Rect[(const int)(q + 1)];
    for(int i = 1; i <= k; i++){
        readInteger(ps[i].x);
        readInteger(ps[i].y);
    }
    for(int i = 1; i <= q; i++){
        readInteger(rs[i].x1);
        readInteger(rs[i].y1);
        readInteger(rs[i].x2);
        readInteger(rs[i].y2);
        rs[i].id = i;
    }
}

boolean *isProtected;

inline void solve_lines(){
    isProtected = new boolean[(const int)(q + 1)];
    memset(isProtected, true, sizeof(boolean) * (q + 1));
    sort(ps + 1, ps + k + 1, cmpp1);
    sort(rs + 1, rs + q + 1, cmpr1);
    lines = SegTree(m);
    int kp = 1, kr = 1;
    for(int i = 1; i <= n; i++){
        while(ps[kp].x == i){
            lines.update(lines.root, ps[kp].y, ps[kp].x);
            kp++;
        }
        while(rs[kr].x2 == i){
            int fx = lines.query(lines.root, rs[kr].y1, rs[kr].y2);
            if(fx < rs[kr].x1)    isProtected[rs[kr].id] = false;
            kr++;
        }
    }
    lines.clean(lines.root);
}

inline void solve_rows(){
    sort(ps + 1, ps + k + 1, cmpp2);
    sort(rs + 1, rs + q + 1, cmpr2);
    rows = SegTree(n);
    int kp = 1, kr = 1;
    for(int i = 1; i <= m; i++){
        while(ps[kp].y == i){
            rows.update(rows.root, ps[kp].x, ps[kp].y);
            kp++;    
        }
        while(rs[kr].y2 == i){
            if(!isProtected[rs[kr].id]){
                int fy = rows.query(rows.root, rs[kr].x1, rs[kr].x2);
                if(fy >= rs[kr].y1)    isProtected[rs[kr].id] = true;
            }
            kr++;
        }
    }
}

const char str[2][10] = {"NO
", "YES
"};
inline void print(){
    for(int i = 1; i <= q; i++){
        printf("%s", str[isProtected[i]]);
    }
}

int main(){
    freopen("brother.in", "r", stdin);
    freopen("brother.out", "w", stdout);
    init();
    solve_lines();
    solve_rows();
    print();
    return 0;
}