2023牛客寒假算法基础集训营1 ACDEFGHKLM

比赛链接

A

题解

知识点:模拟。

显然。

(用char输入到一半直接给答案跳出,WA了两小时,无话可说。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

bool solve() {
    string s;
    cin >> s;
    vector<int> sum(2);
    for (int i = 1;i <= 10;i++) {
        if (s[i - 1] == '1') sum[!(i & 1)]++;
        if (sum[0] > sum[1] + (10 - i + 1) / 2 || sum[1] > sum[0] + (10 - i) / 2) {
            cout << i << '\n';
            return true;
        }
    }
    return false;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

C

题解

知识点:贪心。

显然只要不是 \(0\) 的论文只要不动就会有 \(1\) 的贡献,动了也至多有 \(1\) 的贡献不如不动。因此,记录非 \(0\) 论文数量即可。

时间复杂度 \(O(n)\)

空间复杂度 \(O(n)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int a[100007];
bool solve() {
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i];
    int ans = 0;
    for (int i = 1;i <= n;i++) ans += a[i] != 0;
    cout << ans << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

D

题解

知识点:计算几何,贪心。

\((p_x,p_y)\) 会有四个位置,矩阵内、上方、右方、右上方,分别进行讨论:

  1. \(p_x \leq x,p_y \leq y\) 在矩阵内部,比值最大值为 \(\dfrac{\max(px,x-px)\cdot \max(py,y-py)}{xy}\)
  2. \(p_x > x,p_y < y\) 在矩阵右方,比值最大值为 \(\max\left(\dfrac{xp_y}{xy+(p_x-x)p_y},\dfrac{x(y-p_y)}{xy+(p_x-x)(y-p_y)}\right)\)
  3. \(p_x < x,p_y > y\) 在矩阵上方,比值最大值为 \(\max\left(\dfrac{p_xy}{xy+p_x(p_y-y)},\dfrac{(x-p_x)y}{xy+(x-p_x)(p_y-y)}\right)\)
  4. \(p_x \geq x,p_y \geq y\) 在矩阵右上方,比值最大值为 \(\dfrac{xy}{p_xp_y}\) ,这个需要肉眼观察法qwq。

(手残把 \(y\) 写成 \(x\) ,又瞪了半小时。。。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

bool solve() {
    int x, y, px, py;
    cin >> x >> y >> px >> py;

    if (px <= x && py <= y) {
        cout << fixed << setprecision(10) << 1.0 * max(px, x - px) * max(py, y - py) / x / y << '\n';
    }
    else if (px > x && py < y) {
        double a = 1.0 * x * py / (x * y + py * (px - x));
        double b = 1.0 * x * (y - py) / (x * y + (y - py) * (px - x));
        cout << fixed << setprecision(10) << max(a, b) << '\n';
    }
    else if (py > y && px < x) {
        double a = 1.0 * y * px / (x * y + px * (py - y));
        double b = 1.0 * y * (x - px) / (x * y + (x - px) * (py - y));
        cout << fixed << setprecision(10) << max(a, b) << '\n';
    }
    else if (px >= x && py >= y) {
        cout << fixed << setprecision(10) << 1.0 * x * y / px / py << '\n';
    }
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

E

题解

知识点:计算几何。

前两种操作是平移和旋转,并不会改变两条边的相对位置关系,而第三种操作可以通过镜像翻折改变位置关系。

先确定 \(ABC\)\(DEF\) 靠左的一条边,然后比较长度,如果不同则一定用过第三种操作。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
using ll = long long;
using namespace std;

using ld = long double;
const ld pi = acos(-1.0L);
const ld eps = 1e-8;
template<class T>
struct Point {
    T x, y;
    Point(const T &x = 0, const T &y = 0): x(x), y(y) {}
    Point(const Point &A, const Point &B): x(B.x - A.x), y(B.y - A.y) {}

    Point &operator+=(const Point &P) { x += P.x, y += P.y;return *this; }
    Point &operator-=(const Point &P) { x -= P.x, y -= P.y;return *this; }
    Point &operator*=(const T &k) { x *= k, y *= k;return *this; }
    Point &operator/=(const T &k) { x /= k, y /= k;return *this; }
    friend Point operator-(const Point &P) { return Point(-P.x, -P.y); }
    friend Point operator+(Point A, const Point &B) { return A += B; }
    friend Point operator-(Point A, const Point &B) { return A -= B; }
    friend Point operator*(Point P, const T &k) { return P *= k; }
    friend Point operator/(Point P, const T &k) { return P /= k; }

    bool operator==(const Point &P) const { return (abs(x - P.x) <= eps && abs(y - P.y) <= eps); }

    //点乘
    friend T operator*(const Point &A, const Point &B) { return A.x * B.x + A.y * B.y; }
    //叉乘
    friend T operator^(const Point &A, const Point &B) { return A.x * B.y - A.y * B.x; }

    //P的相对方向,逆时针为1
    int toLeft(const Point &P) const {
        T cross = (*this) ^ P;
        return (cross > eps) - (cross < -eps);
    }

    //向量长度的平方
    T len2() const { return (*this) * (*this); }
    //两点距离的平方
    friend T dist2(const Point &A, const Point &B) { return (A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y); }

    //*一定包含浮点的函数
    //两点距离
    friend ld dist(const Point &A, const Point &B) { return sqrt(dist2(A, B)); }
    //向量长度
    ld len()const { return sqrt(len2()); }
    //向量夹角
    friend ld ang(const Point &A, const Point &B) { return acos(max(-1.0L, min(1.0L, (A * B) / (A.len() * B.len())))); }
    //逆时针旋转rad
    Point rot(const ld rad) const { return { x * cos(rad) - y * sin(rad), x * sin(rad) + y * cos(rad) }; }
    //逆时针旋转参数
    Point rot(const ld cosr, const ld sinr) const { return { x * cosr - y * sinr, x * sinr + y * cosr }; }
};

bool solve() {
    ld xa, ya, xb, yb, xc, yc;
    cin >> xa >> ya >> xb >> yb >> xc >> yc;
    ld xd, yd, xe, ye, xf, yf;
    cin >> xd >> yd >> xe >> ye >> xf >> yf;

    Point<ld> BA({ xb,yb }, { xa,ya });
    Point<ld> BC({ xb,yb }, { xc,yc });
    Point<ld> ED({ xe,ye }, { xd,yd });
    Point<ld> EF({ xe,ye }, { xf,yf });

    if (BA.toLeft(BC) == 1) swap(BA, BC);
    if (ED.toLeft(EF) == 1) swap(ED, EF);

    if (abs(BA.len() - ED.len()) < eps) cout << "NO" << '\n';
    else cout << "YES" << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

F

题解

知识点:并查集。

注意到,即便一个点放完炸弹不能走,但因为我们能控制放炸弹的顺序,炸弹是影响不了我们的路线的。所以实际上,只要炸弹点是连通的,我们就一定可以从这个连通块的任何点开始走,并且以任何点结束,答案便是这个连通块大小的平方。

当然如果炸弹点不在一个连通块就无解。

或者,没有炸弹点,我们就可以把所有连通块大小平方加起来。

用并查集维护连通性,以及连通块大小。

时间复杂度 \(O((m+n) \log n)\)

空间复杂度 \(O(n)\)

代码

#include <bits/stdc++.h>
using ll = long long;
using namespace std;

struct DSU {
    vector<int> fa;
    vector<int> w;

    explicit DSU(int n):fa(n + 1), w(n + 1, 1) {
        for (int i = 1;i <= n;i++)
            fa[i] = i;
    }

    void init(int n) {
        for (int i = 1;i <= n;i++)
            fa[i] = i, w[i] = 1;
    }

    int find(int x) {
        if (fa[x] == x) return x;
        fa[x] = find(fa[x]);
        return fa[x];
    }//按需修改

    bool same(int x, int y) { return find(x) == find(y); }

    bool merge(int x, int y) {
        if (same(x, y)) return false;
        int px = fa[x], py = fa[y];
        fa[px] = py;
        w[py] += w[px];
        return true;
    }//按需修改;注意方向,x合并到y
};

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    DSU dsu(n);
    for (int i = 1;i <= m;i++) {
        int u, v;
        cin >> u >> v;
        dsu.merge(u, v);
    }

    vector<int> c(n + 1);
    for (int i = 1;i <= n;i++) cin >> c[i];

    bool ok = 1;
    int rt = 0;
    for (int i = 1;i <= n;i++) {
        if (c[i]) {
            if (rt) ok &= dsu.same(i, rt);
            else rt = dsu.find(i);
        }
    }
    if (!rt) {
        ll ans = 0;
        for (int i = 1;i <= n;i++) {
            if (i == dsu.find(i)) ans += 1LL * dsu.w[i] * dsu.w[i];
        }
        cout << ans << '\n';
    }
    else if (ok) cout << 1LL * dsu.w[rt] * dsu.w[rt] << '\n';
    else cout << 0 << '\n';
    return 0;
}

G

题解

知识点:线段树,数学。

众所周知,分数是不会一直涨的qwq,所以 \(x_{i+1} = round(10\sqrt {x_i})\)\(x = 0,99,100\) 时会不变,这些点称为不动点。同时,其他点也会快速收敛到 \(99\) 或者 \(100\) ,也就是说每个点最多修改几次就不用改了。

因此,可以写一个伪区间修改的线段树,即单点修改但套一个区间修改的壳子。然后再加一个区间值都为 \(99,100\) 时的优化,可以用最大值和最小值夹逼实现。单点修改时也是同样的,修改到 \(99,100\) 就可以结束了。

特判 \(a_i = 0\) 的情况,为了判断统一可以把这个节点的 \(max\)\(min\) 的信息修改为 \(100\) ,而 \(val\) 还是 \(0\) ,不影响求和。

因为每个点最多修改几次可以看作常数,所以对单点修改次数是 $O(n) $ ,所以复杂度也是 \(O(n\log n)\)

时间复杂度 \(O(n \log n)\)

空间复杂度 \(O(n)\)

代码

#include <bits/stdc++.h>
using ll = long long;
using namespace std;

struct T {
    ll val;
    int mi, mx;
    static T e() { return T{ 0,0x3f3f3f3f,0 }; }
    friend T operator+(const T &a, const T &b) { return { a.val + b.val,min(a.mi,b.mi),max(a.mx,b.mx) }; }
};
///节点元封装类,定义单位元"e"、合并"+"
struct F {
    int k;
    T operator()(const T &x) {
        int val = x.val;
        for (int i = 1;i <= k && val != 99 && val != 100;i++) {
            val = sqrt(val) * 10 + 0.5;
        }
        return T{ val,val,val };
    }
};
///修改元封装类,定义映射"()"
class SegmentTree {
    const int n;
    vector<T> node;
    void update(int rt, int l, int r, int L, int R, F f) {
        if (node[rt].mi >= 99 && node[rt].mx <= 100) return;
        if (r < L || l > R) return;
        if (l == r) {
            node[rt] = f(node[rt]);
            return;
        }
        int mid = l + r >> 1;
        update(rt << 1, l, mid, L, R, f);
        update(rt << 1 | 1, mid + 1, r, L, R, f);
        node[rt] = node[rt << 1] + node[rt << 1 | 1];
    }
    T query(int rt, int l, int r, int x, int y) {
        if (l > y || r < x) return T::e();
        if (x <= l && r <= y) return node[rt];
        int mid = l + r >> 1;
        return query(rt << 1, l, mid, x, y) + query(rt << 1 | 1, mid + 1, r, x, y);
    }

public:
    SegmentTree(int _n):n(_n), node(_n << 2, T::e()) {}
    SegmentTree(int _n, vector<T> &src):n(_n), node(_n << 2, T::e()) {
        function<void(int, int, int)> build = [&](int rt, int l, int r) {
            if (l == r) {
                node[rt] = src[l];
                return;
            }
            int mid = l + r >> 1;
            build(rt << 1, l, mid);
            build(rt << 1 | 1, mid + 1, r);
            node[rt] = node[rt << 1] + node[rt << 1 | 1];
        };
        build(1, 1, n);
    }

    void update(int L, int R, F f) {
        update(1, 1, n, L, R, f);
    }

    T query(int x, int y) {
        return query(1, 1, n, x, y);
    }
};
///线段树,建树O(nlogn)、修改查询O(logn),单点修改、区间查询

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    vector<T> src(n + 1);
    for (int i = 1;i <= n;i++) {
        int x;
        cin >> x;
        if (x) src[i] = { x,x,x };
        else src[i] = { 0,100,100 };
    }
    SegmentTree sgt(n, src);
    while (m--) {
        int op;
        cin >> op;
        if (op == 1) {
            int l, r, k;
            cin >> l >> r >> k;
            sgt.update(l, r, { k });
        }
        else {
            cout << sgt.query(1, n).val << '\n';
        }
    }
    return 0;
}

H

题解

知识点:数学。

因为面积总和不变,记录 \(n^2-1\) 多了或少了几个半圆,一定会出现在最后一块上,直接算即可。

时间复杂度 \(O(n^2)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

bool solve() {
    int n;
    cin >> n;
    int ans = 10;
    for (int i = 1;i <= n * n - 1;i++) {
        for (int j = 1;j <= 4;j++) {
            char x;
            cin >> x;
            if (x == '1') ans++;
            else if (x == '2') ans--;
        }
    }
    cout << ans << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

K

题解

知识点:线性dp。

\(n\leq 2\) 特判为 \(0\)

\(dp[i][j][k]\) 表示为考虑了前 \(i\) 个位置,有 \(j\)\(1\) ,最后两个位置的状态是 \(k\)00,10,01,11 四种状态)。

初值设置:

if (m >= 0) dp[3][0][0] = 0;
if (m >= 1) dp[3][1][0] = dp[3][1][1] = dp[3][1][2] = 0;
if (m >= 2) dp[3][2][1] = dp[3][2][2] = dp[3][2][3] = 1;
if (m >= 3) dp[3][3][3] = 1;

转移方程:

dp[i][j][0] = min(dp[i - 1][j][0], dp[i - 1][j][1]);
dp[i][j][1] = min(dp[i - 1][j][2], dp[i - 1][j][3] + 1);
if (j >= 1) dp[i][j][2] = min(dp[i - 1][j - 1][0], dp[i - 1][j - 1][1] + 1);
if (j >= 2) dp[i][j][3] = min(dp[i - 1][j - 1][2] + 1, dp[i - 1][j - 1][3] + 1);

本题实际可以贪心 \(O(n)\) 过,加点推公式可以 \(O(1)\) 过。

(公式写挂了,没考虑填填满前的几个 \(1\) 的情况不符合规律要特判,于是用dp硬碾过去了qwq。

时间复杂度 \(O(nm)\)

空间复杂度 \(O(nm)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int dp[1007][1007][4];
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    if (n <= 2) {
        cout << 0 << '\n';
        return 0;
    }
    memset(dp, 0x3f3f3f3f, sizeof dp);
    if (m >= 0) dp[3][0][0] = 0;
    if (m >= 1) dp[3][1][0] = dp[3][1][1] = dp[3][1][2] = 0;
    if (m >= 2) dp[3][2][1] = dp[3][2][2] = dp[3][2][3] = 1;
    if (m >= 3) dp[3][3][3] = 1;
    for (int i = 4;i <= n;i++) {
        for (int j = 0;j <= min(i, m);j++) {
            dp[i][j][0] = min(dp[i - 1][j][0], dp[i - 1][j][1]);
            dp[i][j][1] = min(dp[i - 1][j][2], dp[i - 1][j][3] + 1);
            if (j >= 1) dp[i][j][2] = min(dp[i - 1][j - 1][0], dp[i - 1][j - 1][1] + 1);
            if (j >= 2) dp[i][j][3] = min(dp[i - 1][j - 1][2] + 1, dp[i - 1][j - 1][3] + 1);
        }
    }
    cout << min({ dp[n][m][0],dp[n][m][1],dp[n][m][2],dp[n][m][3] }) << '\n';
    return 0;
}

L

题解

知识点:数学。

先团队,再个人,选择是独立的可以分开来算加起来。

团队选 \(1,2,3,4,5\) 次选到的概率都是 \(\dfrac{1}{5}\) ,特别地 \(5\) 才能选中次只选 \(4\) 次就可以结束了,期望 \(\dfrac{1+2+3+4+4}{5}\)

个人同理,期望为 \(\dfrac{1+2+3+3}{4}\)

总和为 \(5.05\) ,选 \(32\)

(傻不拉几的真信了运气题,题都没看直接抽卡,抽了十几发。。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    cout << 32 << '\n';
    return 0;
}

M

题解

知识点:线性dp。

\(dp[i][j]\) 表示为考虑到倒数第 \(i\) 个人,还剩下 \(j\) 个仙贝。

初始状态 \(dp[0][0] = 0\)

枚举给了倒数第 \(i\) 个人 \(k\) 个仙贝的情况转移即可。

(傻不拉几的真信了找规律题,找了1小时屁都没发现。。。

时间复杂度 \(O(nm^2)\)

空间复杂度 \(O(nm)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

double dp[507][507];
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 1;i <= n;i++) {
        for (int j = 0;j <= m;j++) {
            dp[i][j] = dp[i - 1][j];
            for (int k = 1;k <= j;k++) {
                dp[i][j] = max(dp[i][j], dp[i - 1][j - k] + 1.0 * k / j);
            }
        }
    }
    cout << fixed << setprecision(10) << dp[n][m] << '\n';
    return 0;
}

本文来自博客园,作者:空白菌,转载请注明原文链接:http://www.cnblogs.com/BlankYang/p/17058803.html

本文转载于网络 如有侵权请联系删除

相关文章

  • 闪耀在 UNIX 传奇往事中的启示, UNXI 见证者带你一览究竟

    UNIX是现代操作系统的鼻祖。从UNIX到FreeBSD,再到OSX,最后到iOS应运而生。由于UNIX的版权纠纷和Minix的封闭,Linux诞生了,而后又产生了Android。UNIX的创造者奠定了操作系统的标准基石,UNIX的“分而治之”设计哲学——让每个程序做好一件事;要做一件新的工作,就构建新程序,而不是通过增加新“特性”使旧程序复杂化——被优秀程序员奉为圭臬。如果将操作系统比喻成酒,那么UNIX应该是所有操作系统的“基酒”,因为有了它,才有了现在的互联网/物联网世界。所有行业都在数字化,数字化的服务就是操作系统控制的各种程序,我们现在依赖的各种网站、云计算、大数据、手机通信及航空航天技术的背后都是操作系统在控制调度的。自1969年在贝尔实验室的阁楼上诞生以来,UNIX操作系统的发展远远超出其创造者们的想象。它带动了许多创新软件的开发,影响了无数程序员,改变了整个计算机技术的发展轨迹。那么,UNIX操作系统为何如此重要?UNIX是如何产生的?贝尔实验室为何诞生了那么多图灵奖得主?中国操作系统的未来会如何?......带着这些问题,4月20日晚8点,异步社区特邀CSDN创始人蒋

  • 2020年度 AI 安防十大关键词 | 年终盘点

    以此为序,再奏华章。作者|余快 “我们只为了活下去。”这是海康威视总裁胡扬忠曾接受雷锋网AI掘金志采访时所言。如今回看,这句话在2020年显得尤为应景。2020年,在内碰经济下行,外遇中美竞争的寒冬中,贯穿全年、全球的疫情给寒冬再覆一层积雪。重压之下,新基建、十四五规划、两会揭开序幕,国家宏观政策托起经济底座;市场顽强自救,人工智能、大数据、云计算、物联网等技术正以惊叹的速度改变产业。跌宕起伏中,魔幻二字,成为2020年的真实写照。回眸这一年,哪些词能够成为安防行业的缩影,哪些词能够成为安防时代长河的脉搏?针对这一选题,在即将结束的2020年,AI掘金志通过采访数十位业内专家、企业高管,概括出过去一年来AI安防市场的十大关键词,以回顾不平凡的2020。1、上市 充斥着动荡、寒冬的2020年没有熄灭AI安防领域奔涌的火把。2020年一股AI企业上市潮正是信号之一。其中,以CV为核心的AI安防市场尤为明显。继旷视在2019年向港交所提交上市材料后,依图、云从、云天励飞、寒武纪等AI独角兽相继在2020年向IPO发起冲击。毋容置疑,智能安防目前是最成熟的AI视觉应用领域。除了更加成熟的CV

  • Android TreeView实现带复选框树形组织结构

    之前做项目的时候做人员组织架构时候需要用到,同样可以用于目录视图。简单搜了一下没有合适的,只找到一个基础的有瑕疵的树形结构,就在基础上改了增加了复选框以及简化了部分代码。下面上演示效果图,时长25秒,手机卡见谅。复选框有两种设计模式:1、子节点选中则父节点选中,适合多级多item下方便了解哪些被选中;2、子节点全部选中父节点才选中,更符合日常逻辑,适合少数量以及少层级。下面上主要代码:首先上MainActivity,主要作用上加载layout以及读取数据。实际中一般从数据库获取。命名较为随意请见谅。publicclassMainActivityextendsAppCompatActivity{ List<Nodelist=newArrayList<Node(); privateTreeListViewlistView; privateRelativeLayoutrelativeLayout,rl; @Override protectedvoidonCreate(BundlesavedInstanceState){ super.onCreate(savedInstance

  • docker搭建环境如何配置端口

    文章简介在上面一篇文章中,分享过如何搭建和使用dnmp,今天分享如何修改dnmp中PHP容器的端口映射功能。问题归纳在PHP容器中,安装了一个swoole扩展,启动了一个server,端口是9501。在安装dnmp中,docker配置中将9501给暴露出来了,按理来说,启动服务之后宿主机就可以正常访问了,但是提示如下信息。然后尝试去telnet端口号,却发现是测试不通。✘ert@192~telnet127.0.0.19501 Trying127.0.0.1... Connectedtolocalhost. Escapecharacteris'^]'. Connectionclosedbyforeignhost.复制问题排查第一步,检测PHP容器内的9501端口是否正常启动。发现端口是正常启动的,接下来,看看是不是映射问题。/www#netstat-anp|grep9501 tcp000.0.0.0:95010.0.0.0:*LISTEN69511/tools.Master复制第二步,查看docker的PHP容器端口映射有哪些。✘ert@192~dockerp

  • Kubernetes 从0到1

    Kubernetes,又称为k8s(首字母为k、首字母与尾字母之间有8个字符、尾字母为s,所以简称k8s)或者简称为“kube”,是一种可自动实施Linux容器操作的开源平台。它可以帮助用户省去应用容器化过程的许多手动部署和扩展操作。也就是说,您可以将运行Linux容器的多组主机聚集在一起,由Kubernetes帮助您轻松高效地管理这些集群。而且,这些集群可跨公共云、私有云或混合云部署主机。因此,对于要求快速扩展的云原生应用而言(例如借助ApacheKafka进行的实时数据流处理),Kubernetes是理想的托管平台。Kubernetes最初由Google的工程师开发和设计。Google是最早研发Linux容器技术的企业之一,曾公开分享介绍Google如何将一切都运行于容器之中(这是Google云服务背后的技术)。Google每周会启用超过20亿个容器——全都由内部平台Borg支撑。Borg是Kubernetes的前身,多年来开发Borg的经验教训成了影响Kubernetes中许多技术的主要因素。趣事:Kubernetes徽标的七个轮辐代表着项目最初的名称“九之七项目”(Projec

  • rook使用教程,快速编排ceph

    文章目录安装使用创建pool创建pvc总结kubernetes集群三步安装安装gitclonehttps://github.com/rook/rook cdcluster/examples/kubernetes/ceph kubectlcreate-foperator.yaml复制查看operator是否成功:[root@dev-86-201~]#kubectlgetpod-nrook-ceph-system NAMEREADYSTATUSRESTARTSAGE rook-ceph-agent-5z6p71/1Running088m rook-ceph-agent-6rj7l1/1Running088m rook-ceph-agent-8qfpj1/1Running088m rook-ceph-agent-xbhzh1/1Running088m rook-ceph-operator-67f4b8f67d-tsnf21/1Running088m rook-discover-5wghx1/1Running088m rook-discover-lhwvf1/1Runni

  • 一文说清HBase的存储结构

    本文经授权转载于spacedong公号IDdd_technology阅读文本大概需要7分钟。 前言HBase是一个分布式的、多版本、面向列的开源KV数据库。运行在HDFS的基础上,支持PB级别、百万列的数据存储。作为性能如此强大的KV数据库,HBase的存储结构究竟是怎样的呢?面向列的存储结构究竟有什么样的不同之处呢?接下来会详细讲解这部分。HBase的存储结构为了清晰地表述这个,我们把HBase的存储结构分为逻辑结构和物理结构两个部分。逻辑存储结构通过下图直观地展示HBase的逻辑存储结构:HBase逻辑视图在本图中,列簇(ColumnFamily)对应的值就是info和area,列(Column或者称为Qualifier)对应的就是name、age、country和city,Rowkey对应的就是Row1和Row2,Cell对应的就是具体的值。Rowkey:表的主键,按照字典序排序。列簇:在HBase中,列簇将表进行横向切割。列:属于某一个列簇,在HBase中可以进行动态的添加。Cell:是指具体的Value。Version:在这张图里面没有显示出来,这个是指版本号,用时间戳(Ti

  • 【AAAI 2019 阿里】分层多任务的序列标注方法

    序列标注在SLU语义理解具有重要地位,主要用于语义槽的提取,便于机器理解用户query的语义。常见的序列标注方式有Jordan-RNN、BiLSTM-CRF等。为提高序列标注的准确度,加入用户意图的识别任务。阿里的这篇论文主要观点也是加入多任务,但并非用户意图分类的任务,而是分词和NER的任务。分词任务(chunking)主要用于判别词语的边界、NER任务主要识别实体的类型(例如PERSON、LOCATION等),可以理解为分词任务纯是句法层面的任务(没有语义层面)、NER是底层的语义识别、上层的序列标注是更加细腻度的语义槽提取。三个任务加在一起的进行多任务训练的方式有很多种,具体如图1所示。多任务的几种组合方式(b)中是最原始的multi-task方式,就是底层共享,output层分离分别用作三个不同的任务,共同tune底下共享部分的模型参数,(c)中结构的观点是深度学习模型在底层一般是句式句法上的特征、层数越深语义越抽象,(d)中沿用了(c)的假设但加入了残差连接,将上一层的输入以及输出的预测标签均残差连接到下一层的输入。具体看一下slot的定义就知道了三个不同的任务分别做什么,如

  • 从视频中每X秒创建一个缩略图

    -vframes 操作选项 从视频中输出一帧生成文件: ffmpeg-iinput.flv-ss00:00:14.435-vframes1out.png复制 这个例子将会 seek 到时间进度条位置在0h:0m:14sec:435msec处并输出一帧(-vframes1)输出生成一个PNG文件. fps 视频filter 每一秒输出一帧图像为图片,图片命名为 out1.png, out2.png, out3.png,依次顺序输出.ffmpeg-iinput.flv-vffps=1out%d.png复制 每一分钟截一次图,命名 img001.jpg, img002.jpg, img003.jpg,依次顺序递增.例子中的 %03d 为用来规定每个输出图片的序数将格式化使用3位数.ffmpeg-imyvideo.avi-vffps=1/60img%03d.jpg复制 每十分钟输出一张图片:ffmpeg-itest.flv-vffps=1/600thumb%04d.bmp复制 select 视频filter 每个I帧生成一张图片:ffmpeg-iinput.flv-vf"selec

  • 为什么我们从Python切换到Go?

    为什么我们从Python切换到Go?切换到新的编程语言向来是关键一步,尤其是当你的团队只有一位成员有该语言的使用经验时。今年年初,我们将Stream的主要编程语言从Python切换到Go。本文将解释为什么我们决定舍弃Python并切换到Go的一些原因。使用Go的原因原因一——性能Go的运行速度很快!Go非常快,其性能与Java或C++类似。在我们的用例中,Go比Python快30倍。这是一个用于比较Go和Java的小型基准游戏。原因二——语言自身性能问题对于许多应用程序来说,编程语言只是应用程序和数据库之间的粘合剂。语言本身的性能通常并不重要。然而,Stream是一家为500家公司和2亿多终端用户提供源基础架构动力的API提供商。多年来,我们一直在优化Cassandra,PostgreSQL,Redis等,但最终,你将达到所用语言的极限。Python是一门伟大的语言,但对于序列化/反序列化、排序和聚合等用例来说,其性能表现非常缓慢。我们经常遇到性能问题,Cassandra需要花费1ms来检索数据,Python则会花费接下来的10ms将其转化为对象。原因三——开发人员的工作效率和创造力不

  • 微信“小游戏”今日重磅上线 H5手游将迎真正爆发点

    今日腾讯微信通过多个官方微信公众号正式公布了“小游戏”发布的消息,这昭示着腾讯微信正式拥抱H5手游市场,给多年来一直等待H5游戏机遇的开发者送上了终极新年大礼包。部分微信用户今日进入微信已能看到小游戏的开屏登陆页面,可见微信这次叫来势汹汹。据了解,腾讯在几个月前就开始向部分国内厂商预定首批上线的H5产品。第一批上线游戏中,将同时包括腾讯内部自研和外部研发商产品,类型上以强社交性的轻度休闲游戏为主。根据微信多个官方公告披露的信息,小游戏目前尚在此前微信“小程序”的功能范畴之内,笔者认为不排除未来“小游戏”将成为单独的微信产品概念向行业郑重推荐。根据微信公众平台官方微信号公告表示:“小游戏已于今日正式上线,游戏开发者可以在微信公众平台上查阅小游戏开发文档,下载最新版的开发者工具。”需要注意的是,微信表示:“小程序每次发布需要经过腾讯的审核。”小游戏目前的入口存在两个地方:1.从「发现-游戏」进入「小游戏」,并查看好友玩过的小游戏;2.在微信的「搜一搜」中搜索小游戏的名称,例如:跳一跳,就能直接开始玩了。腾讯“微信派”官方微信号就预演了微信小游戏的游戏效果,重点介绍了官方推荐的小游戏“跳一跳

  • 跨语言调用C#代码的新方式-DllExport

    简介上一篇文章使用C#编写一个.NET分析器文章发布以后,很多小伙伴都对最新的NativeAOT函数导出比较感兴趣,今天故写一篇短文来介绍一下如何使用它。在以前,如果有其他语言需要调用C#编写的库,那基本上只有通过各种RPC的方式(HTTP、GRPC)或者引入一层C++代理层的方式来调用。自从微软开始积极开发和研究NativeAOT以后,我们有了新的方式。那就是直接使用NativeAOT函数导出的方式,其它语言(C++、Go、Java各种支持调用导出函数的语言)就可以直接调用C#导出的函数来使用C#库。废话不多说,让我们开始尝试。开始尝试我们先来一个简单的尝试,就是使用C#编写一个用于对两个整数求和的Add方法,然后使用C语言调用它。1.首先我们需要创建一个新的类库项目。这个大家都会了,可以直接使用命令行新建,也可以通过VS等IDE工具新建。dotnetnewclasslib-oCSharpDllExport 复制2.为我们的项目加入NativeAOT的支持,根据.NET的版本不同有不同的方式。如果你是.NET6则需要引入Microsoft.DotNet.ILCompiler这个Nug

  • esp8266物联网开发一:MicroPython初战江湖

    用esp8266做的物联网开发,涉及到固件烧写,固件擦除,代码编写等方面,做一一记录。 1.固件烧写 首先,下载固件烧写工具:https://www.espressif.com/sites/default/files/tools/flash_download_tools_v3.6.3.rar,具体烧写包我会在后面附加。 然后,下载micropython固件包:http://www.micropython.org/download/esp8266/,一般选择512k的包即可。 打开固件烧写工具,点击“esp8266downloadtools”,在打开的界面中设置好参数: 在烧写之前,先点击ERASE按钮进行擦除操作,保证烧写的固件不受干扰。 然后点击START进行烧写操作。 进度表跑完,提示FINISH的时候,代表烧写完毕并成功。   2.开发环境 开发环境使用ESPlorer,网上有很多,可以百度下,具体界面如下: 左半区为代码编码区,右半区为和硬件通讯调试区。   3.esp8266联网 在进行开发之前,一般需要进行芯片联网设置的,具体操作如下: 首先,准

  • koolshare 安装

    说一下遇到的麻烦 总体来说,mac版的vmvare和win版的区别挺大的,各种缺功能。 1、选择光盘时,也要选择总线类型为IDE    2、启动了koolshare后,修改koolshare的ip为主机可访问的ip 视频里访问的是192.168.1.1,这个是网关,根本无法访问。 我把koolshare设置为桥接模式,之后vi/etc/config/network把地址设置为192.168.1.10(路由器的网关是192.168.1.1) 参考网址:https://blog.csdn.net/NRlovestudy/article/details/104514101 访问192.168.1.10即可   最后这个没用到,原因是镜像800M,但是我的梯子的网速只有几十KB,实在是太慢了。  

  • 前端页面获取URL拼接的参数值

    functiongetQueryString(name){ varreg=newRegExp('(^|&)'+name+'=([^&]*)(&|$)','i') varr=window.location.search.substr(1).match(reg) if(r!=null){ returndecodeURI(r[2]) }else{ returnnull } } 例如: http://192.168.25.54:8000/test.html?id=123456789&name=姓名 varid=getQueryString("id"); varname=getQueryString("name"); 可封装成工具类复制  

  • html

    1

  • 【Objective-C基础教程-读书笔记】第1章 启程

    在第1章里面,作者主要以一种站在世界中心呼唤爱的姿态,给读者们打打鸡血洗洗脑,鼓励大家,投入时间学习Objective-C,值得啊! 首先,Objective-C既能用来开发OSX平台上的APP,又能用来开发iOS平台上的APP。 其次,Objective-C一直与时俱进,二十多年来从未停止过更新与改进。(咦,微软的MFC好像也是这么说的……) 最后,尽管苹果设备很贵,但Xcode和Cocoa这些都是免费的啊,特别是最近,iOS设备的真机调试权限也免费放开了。 作为一个刚刚启程的程序员,仿佛之间,我感觉自己正站在一个坑的边边上,有一把声音从坑里悠悠传来:快到坑里来吧,炎炎夏日,坑里面很凉爽的…… 系列文章索引:http://www.cnblogs.com/duxiuxing/p/5492374.html

  • CSS精灵图Sprite,offset()方法 获取偏移位置

    一.CSS精灵图Sprite 精灵技术:就是一种处理网页背景图像的方式,它需要将一个页面中涉及到的所有或一部分较小的背景图像合并到一张较大的图片中,然后再将这个图片应用到网页中。通常情况下,我们只是将背景图像中那些较小的、零碎的图像集中到一个大的图像中,这个较大的图像被称为精灵图(也被称为雪碧图) 1.利用CSS的“background-image”,“background-repeat‘,”background-position“的组合进行背景定位;background-position来移动背景图(用数字精准定位出背景图片的位置),从而只显示背景图的一部分。如下图(无效果图) 2.优点: 使用精灵图可以减少图片的体积; 也可以显著的减少对服务器的请求次数; 提高网页的加载速度 解决命名困扰(只需要在集合的图片命名) 更换风格方便(只需改变一张或少张图片上的样式) 3.缺点: 在图片合并的时候,需要把多张图片有序的、合理的合并成一张图片,每个小图之间需要预留足够的空间(photoshop或其他工具测量计算每个背景单元的精确位置); 在宽屏或者高分辨率的屏幕下来自适应页面宽度时

  • php绝对路径与相对路径之间关系的的深入研究http://evanwukong.blog.163.com/blog/static/13483649520117105319400/

    php绝对路径与相对路径之间关系的的深入研究 2010-03-0310:02[小 大]来源:中国站长站综合 评论: 0 转发至:       站长交易(http://jy.chinaz.com)友情链接交换 企业建站找313建站大师,招分销商 核心提示:php中好像不能像asp那样用“/”表示根目录,代之以$_SERVER['DOCUMENT_ROOT'],其它则相同:../表示向上一层。./表示当前层。假如现在a/b/c/s.php要调用根目录下的/bb/s2.txt php中好像不能像asp那样用“/”表示根目录,代之以$_SERVER['DOCUMENT_ROOT'],其它则相同:../表示向上一层。./表示当前层。假如现在a/b/c/s.php要调用根目录下的/bb/s2.txt,则:   $RootDir=$_SERVER['DOCUMENT_ROOT']; $fireDir="$RootDir/bb/s2.txt"; 或者:“

  • SpringBean创建源码

    一、DefaultListableBeanFactory   DefaultListableBeanFactory是BeanFactory的继承接口 解析xml: doRegisterBeanDefinitions parseBeanDefinitions postProcessXml 二、将BeanDefinition注册到容器中   processBeanDefinition beanDefinitionMap bean标签的存储,name作为key,beanDefinition作为value this.beanDefinitionMap.put(beanName,beanDefinition); this.beanDefinitionNames.add(beanName); removeManualSingletonName(beanName);复制   三、Bean对象的实例化 for(StringbeanName:beanNames){ RootBeanDefinitionbd=getMergedLocalBeanDefi

  • 第一天,入坑 —— 2014.10.24

       好吧,必须得承认,AngurlarJS我想学很久了,http://www.angularjs.cn/tag/AngularJS 这网址,我进去的次数不下10次了有,但是没有一次是真正开始的,唯一的一次,在 AngularJS入门教程00:引导程序 这里看到要用git,so我花了大概半天多时间去把git入门参考手册全部过了一遍,就是这http://gitref.org/zh/creating/,然后就没有然后了。    "等了好久终于等到今天,梦了好久终於...",对,没错,今天我‘胡汉三’第N+1次又来到了 http://www.angularjs.cn/tag/AngularJS,并且这次我有了后续,对,就是那样,我真的开始搞AngularJS了。。。      ......      ......      ......     

相关推荐

推荐阅读