题解，Java

Posted 2023-04-02 炒饭加蛋挞

题解 

Codeforces Round 860 (Div. 2)
A-Showstopper
思路：对同一位的ai，bi进行a[n],b[n]不交换，a[n],b[n]交换,a[i],b[i]交换比较

#include<iostream>
#include<cstring>
using namespace std;
int a[110], b[110];
int main()

    ios::sync_with_stdio(false);
    int t;
    cin >> t;
    while (t--) 
        memset(a, 0, sizeof(a));
        memset(b, 0, sizeof(b));
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++) 
            cin >> a[i];
        
        for (int i = 1; i <= n; i++) 
            cin >> b[i];
        
        bool flag = 0;
        for (int i = 1; i <= n; i++) 
            if (a[i] > a[n] || b[i] > b[n]) 
                if (a[i] > b[n] || b[i] > a[n])    //交换后
                    if (b[i] > a[n] || a[i] > b[n])
                        flag = 1;
                
            
        
        if (flag)
            cout << "NO" << '\\n';
        else
            cout << "YES" << '\\n';
    
    return 0;

B-Three Sevens
思路：二维数组存不下，建立vector,从后往前推，对于每天没出现的编号挑选一个，若无答案为-1

#include<bits/stdc++.h>
#include<iostream>
#include<vector>
#include<map>
#include<set>
#include<cstring>
const int maxn = 5e4 + 10;
using namespace std;
vector<int>v[maxn];
vector<int>e;
bool vis[maxn];
void solve() 
    e.clear();
    memset(vis, 0, sizeof(vis));
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) 
        v[i].clear();
        int m;
        cin >> m;
        for (int j = 1; j <= m; j++) 
            int a;
            cin >> a;
            v[i].push_back(a);
        
    
    for (int j = n; j >= 1; j--) 
        bool flag = 0;
        for (auto k = v[j].begin(); k != v[j].end(); k++) 
            if (!vis[*k] && !flag) 
                flag = 1;
                e.push_back(*k);
            
            vis[*k] = 1;
        
        if (!flag) 
            cout << "-1" << "\\n";
            return;
        
    
    reverse(e.begin(), e.end());
    for (auto k = e.begin(); k != e.end(); k++) 
        cout << *k << ' ';
    
    cout << '\\n';

int main()

    ios::sync_with_stdio(false);
    int t;
    cin >> t;
    while (t--) 
        solve();
    

C. Candy Store
思路：性质：范围内（xi*yi）的最大公约数*范围内yi的最小公倍数=zi，
 不断更新范围内最小公倍数，最大公约数 ,当最大公约数%最小公倍数不等于0时，
 更换最小公倍数，最大公约数同时ans++

#include<bits/stdc++.h>
#include<iostream>
#include<queue>
#include<map>
#define int long long
const int maxn = 1e6 + 10;
using namespace std;
int gcd(int a, int b)                     //辗转相除法求最大公约数
    return !b ? a : gcd(b, a % b);

struct node 
    int x, y;
a[maxn];
void solve() 
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) 
        cin >> a[i].x >> a[i].y;
    
    int ans = 1;
    int t = a[1].y;
    int c = a[1].x * a[1].y;
    for (int i = 2; i <= n; i++) 
        t = t * a[i].y / gcd(t, a[i].y);    //范围内最小公倍数
        c = gcd(c, a[i].x * a[i].y);          //xi*yi范围内的最大公约数
        if (c % t) 
            ans++;
            c = a[i].x * a[i].y;
            t = a[i].y;
        
    
    cout << ans << '\\n';

signed main()

    ios::sync_with_stdio(false);
    int t;
    cin >> t;
    while (t--) 
        solve();
    
    return 0;

D. Shocking Arrangement
 错解：目的出现错误，贪心使之小于Max

#include<bits/stdc++.h>
#include<iostream>
#include<queue>
#include<algorithm>
#include<set>
#include<math.h>
#include<vector>
using namespace std;
#define int long long
const int maxn = 3e5 + 10;
vector<int>p;              //set默认从小到大排列并且去重不采用
queue<int>q;
void solve() 
    int n;
    cin >> n;
    if (n == 1) 
        int a;
        cin >> a;
        cout << "No" << '\\n';
        return;
    
    for (int i = 1; i <= n; i++) 
        int a;
        cin >> a;
        p.push_back(a);
      
    sort(p.begin(), p.end());          //
    //sort(p.begin(), p.end(), greater<int>()); //从大到小排序
    auto Max = *p.rbegin() - *p.begin();
    int sum = 0;
    while (!p.empty()) 
        sum = abs(sum + *p.rbegin());
        if (sum <= Max) 
            q.push(*p.rbegin());
            p.pop_back();
        
        else 
            sum = abs(sum - *p.rbegin());
            sum = abs(sum + *p.begin());
            if (sum > Max) 
                cout << "No" << '\\n';
                p.clear();
                q = queue<int>();                      //队列的清空：赋初值
                return;
            
            else 
                q.push(*p.begin());
                p.erase(p.begin());
            
        
    
    cout << "Yes" << '\\n';
    while (!q.empty()) 
        cout << q.front() << ' ';
        q.pop();
    
    cout << '\\n';

signed main()
    ios::sync_with_stdio(0);
    int t;
    cin >> t;
    while(t--) 
        solve();
    
    return 0;

思路：目的：使得区间内范围相加abs最小，即使之靠近0的这个值
 当sum>0时，选择最小，当sum<=0时选择最大，考虑全为0的特殊情况
 

#inclide<bits/stdc++.h>
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
#define int long long
int mod = 1e7 + 7;
void solve() 
    int n;
    cin >> n;
    int zero = 0;
    vector<int>v;
    for (int i = 0; i < n; i++)
        int x;
        cin >> x;
        if (x == 0)
            zero++;
        else
            v.push_back(x);
    
    if (zero == n)                    //全为0的情况
        cout << "NO\\n";
    else
        sort(v.begin(), v.end());
        vector<int>ans;
        while (zero--)
            ans.push_back(0);
        int sum = 0;
        int l = 0, r = v.size() - 1;
        while (l <= r)
            if (sum >= 0)
                ans.push_back(v[l]);
                sum += v[l];
                l++;
            
            else
                ans.push_back(v[r]);
                sum += v[r];
                r--;
            
        
        cout << "YES\\n";
        for (auto i : ans)
            cout << i << " ";
        cout << '\\n';
    

signed main()

    int t;
    cin >> t;
    while (t--)
        solve();
    
    return 0;

第一次测试

A - Super Ryuma 
思路：两点重合，0步，直接满足三种条件，1步，满足1，2；2，3；1，3；3，3；两步，否则三步

#include<iostream>
typedef long long ll;
using namespace std;
int main()

    ios::sync_with_stdio(false);
    ll a, b, c, d;
    cin >> a >> b >> c >> d;
    if (a == c && b == d)
        cout << 0 << '\\n';
    else if (a + b == c + d || a - b == c - d || abs(a - c) + abs(b - d) <= 3)  //直接满足三种条件
        cout << 1 << '\\n';
    else   //图形
        if (abs(a - c) + abs(b - d) <= 6)  //两次第三种情况：两步方框距离
            cout << 2 << '\\n'; 
        else
            int flag = 0;
            for (int i = a - 3; i <= a + 3; i++)                 //第一种与第三种，第二种与第三种
                for (int j = b - 3; j <= b + 3; j++)         //找方框里面能否有直接斜线到终点的
                    if (abs(i - a) + abs(j - b) <= 3 && i + j == c + d || i - j == c - d)
                        flag = 1;
                
            if (flag) 
                cout << 2 <<'\\n';
            else                                                          //第一种与第二种
                if (((a + b) & 1LL) == ((c + d) & 1LL)) cout << 2 <<'\\n'; //看对角线奇偶性
                else cout << 3 << '\\n';
            
        
    
    return 0;

简化版
 

#include <iostream>
#include<math.h>
using namespace std;
int main()   
    long long a, b, c, d;
    cin >> a >> b >> c >> d;
        long long p = abs(c - a), q = abs(d - b);
        if (p == 0 && q == 0) cout << '0' << '\\n';
        else if (p == q || p + q <= 3) cout << '1' << '\\n';//1，3；2，3曼哈顿距离小于等于3即可
        else if ((p + q) % 2 == 0 || p + q <= 6 || abs(p - q) <= 3) cout << '2' << '\\n';
        else     cout << '3' << '\\n';

F - Third Avenue
思路：bfs,防止时间超限，将传送门用vector<PI>g[26]存储，遇见传送门传送且每个字母只能用一次
 

#include<iostream>
#include<queue>
#include<vector>
using namespace std;
#define PI pair<int,int>
const int maxm = 2e3 + 5;
int dir[4][2] =  1,0,0,1,-1,0,0,-1 ;
int mark[maxm][maxm];
char s[maxm][maxm];
vector<PI> g[26];
int vis[26];
PI st, ed;
int n, m;
struct node 
    int x,y;
;
void bfs() 
    queue<PI>q;
    q.push(st);
    mark[st.first][st.second] = 1;
    while (!q.empty()) 
        int x = q.front().first;
        int y = q.front().second;
        q.pop();
        for (int k = 0; k < 4; k++) 
            int xx = x + dir[k][0];
            int yy = y + dir[k][1];
            if (xx <= 0 || xx > n || yy <= 0 || yy > m|| mark[xx][yy]|| s[xx][yy] == '#')
                continue;
            mark[xx][yy] = mark[x][y] + 1;
            q.push( xx,yy );
        
        if (s[x][y] >= 'a' && s[x][y] <= 'z') 
            if (!vis[s[x][y] - 'a']) //每种字母只能用一次
                vis[s[x][y] - 'a'] = 1;
                for (auto i : g[s[x][y] - 'a']) 
                    if (mark[i.first][i.second])continue;
                    mark[i.first][i.second] = mark[x][y] + 1;
                    q.push(i);
                
            
        
    

int main() 
    cin >> n >> m;
    for (int i = 1; i <= n; i++) 
        for (int j = 1; j <= m; j++) 
            cin >> s[i][j];
            if (s[i][j] == 'S') 
                st =  i,j ;
            
            else if (s[i][j] == 'G') 
                ed =  i,j ;
            
            else if (s[i][j] >= 'a' && s[i][j] <= 'z') 
                g[s[i][j] - 'a'].push_back( i,j );
            
        
    
    bfs();
   cout<<mark[ed.first][ed.second] - 1<<'\\n';
    return 0;

java(4)

在书本对以前网上学到的知识点进行落实，发现书本上有很多网上没有涉及到区域，于是又重温了一遍，感觉对知识点理解加深了，整理出之前遗落的知识点，然后就是在代码进行动手能力加强

 

每日一刷与题解：Java基础知识+sql

JAVA基础题

题解：接口是多继承

题解：A、Set不允许存在重复元素，所以最多只能有一个空值
B、List可以有多个空值
C、Set不可以包含重复元素
D、Set是无序的

题解：

修饰符	类中	同包	不同包的子类	不同包非子类
public	Y	Y	Y	Y
protected	Y	Y	Y	N
default	Y	Y	N	N
private	Y	N	N	N

题解：子类重写父类方法时，方法的访问权限不能小于原访问权限，在接口中，方法的默认权限就是public，所以子类重写后只能是public

下面程序的输出结果为（ ）

public class Demo {
    public static String sRet = "";
    public static void func(int i) {
        try {
            if (i % 2 == 0)
                throw new Exception();
        } catch (Exception e) {
            sRet += "0";
            return;
        } finally {
            sRet += "1";
        }
        sRet += "2";
    }
    public static void main(String[] args) {
        func(1);
        func(2);
        System.out.println(sRet);
    }
}

答案：1201
题解：
①调用func(1),if不符合，直接进入finally，sRet=“1"
②finally语句中没有返回值，故继续向下执行，sRet=“12”
③调用func(2),if符合，sRet=“120”，此时有返回值!!!
④调用finally语句，sRet=“1201”
⑤因为已经有返回值了，finally之后的语句也不再执行，sRet=“1201”。

题解：单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
特点：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
优点：
1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例）。
2、避免对资源的多重占用（比如写文件操作）。
缺点：
没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

题解：眼花，没有看到d选项

• int和int之间，用==比较，肯定为true。基本数据类型没有equals方法
• int和Integer比较，Integer会自动拆箱，== 和 equals都肯定为true
• int和new Integer比较，Integer会自动拆箱，调用intValue方法, 所以 == 和 equals都肯定为true
• Integer和Integer比较的时候，由于直接赋值的话会进行自动的装箱。所以当值在[-128,127]中的时候，由于值缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是直接从缓存中获取已经创建好的Integer对象。而当大于这个区间的时候，会直接new Integer。
• 当Integer和Integer进行==比较的时候，在[-128,127]区间的时候，为true。不在这个区间，则为false
• 当Integer和Integer进行equals比较的时候，由于Integer的equals方法进行了重写，比较的是内容，所以为true
• Integer和new Integer ： new Integer会创建对象，存储在堆中。而Integer在[-128,127]中，从缓存中取，否则会new Integer.
  所以 Integer和new Integer 进行==比较的话，肯定为false ; Integer和new Integer 进行equals比较的话，肯定为true
• new Integer和new Integer进行==比较的时候，肯定为false ; 进行equals比较的时候，肯定为true,原因是new的时候，会在堆中创建对象，分配的地址不同，==比较的是内存地址，所以肯定不同
• 装箱过程是通过调用包装器的valueOf方法实现的
• 拆箱过程是通过调用包装器的xxxValue方法实现的（xxx表示对应的基本数据类型）
  总结:Byte、Short、Integer、Long这几个类的valueOf方法实现类似的。所以在[-128,127]区间内，==比较的时候，值总是相等的（指向的是同一对象），在这个区间外是不等的。
  而Float和Double则不相等， Boolean的值总是相等的

题解：抽象类
特点:
1.抽象类中可以构造方法
2.抽象类中可以存在普通属性，方法，静态属性和方法。
3.抽象类中可以存在抽象方法。
4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。
接口
1.在接口中只有方法的声明，没有方法体。
2.在接口中只有常量，因为定义的变量，在编译的时候都会默认加上
public static final
3.在接口中的方法，永远都被public来修饰。
4.接口中没有构造方法，也不能实例化接口的对象。
5.接口可以实现多继承
6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法
7.则实现类定义为抽象类。

SQL语句

SQL44：将id=5以及emp_no=10001的行数据替换成id=5以及emp_no=10005

UPDATE titles_test
SET emp_no = REPLACE(emp_no, 10001, 10005)
WHERE id = 5;

SQL45：将titles_test表名修改为titles_2017

alter table titles_test rename titles_2017;

SQL46：在audit表上创建外键约束，其emp_no对应employees_test表的主键id

alter table 表名 add【 constraint 约束名】 foreign key(字段名) references 主表（被引用列）;
alter table audit add foreign key(emp_no) references employees_test(id);

SQL48：将所有获取奖金的员工当前的(salaries.to_date=‘9999-01-01’)薪水增加10%

//先连接两表再查询
update salaries s 
join emp_bonus e 
on s.emp_no=e.emp_no
set salary=salary*1.1
where to_date='9999-01-01'

SQL50：将employees表中的所有员工的last_name和first_name通过(’)连接起来

select concat(last_name,"'",first_name) 
from employees;