Exploring Pyramids UVALive - 3516/AcWing 284. 金字塔（区间DP）

于 2019-08-16 21:53:48 发布
阅读量149 收藏
点赞数
分类专栏： 0x53区间DP 0x03递归 0x22深度优先搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41835683/article/details/99685792
版权

题目链接：https://cn.vjudge.net/problem/UVALive-3516

https://www.acwing.com/problem/content/286/

题意：一颗多叉树，从根节点出开始，每次尽量往左走，走不通就回溯，把遇到的字母顺次记录下，可以得到一个序列，

问你有多少种棵树与之对应。

题解：d[i][j]表示s_{i},s_{i+1},...,s_{j},对用的子树的个数，边界条件是d(i,i)=1;d[i][j]=0;因为子树的入口和出口必然相同，

其他情况，设子树的第一个分支在s_{k}时，回到树根，此时必然有s_{i}=s_{k},则这个分支对应的序列是s_{i+1},s_{i+2},...,s_{k-1},

方案数为d(i+1,k-1)其他分支对应的访问序列是s_{k},s_{k+1},...,s_{j},方案数d(k,j)。

那么递推式就是d(i,j)=sum\left \{ d(i+1,k-1)*d(k,j) |i+2<=k<=j,s_{i}=s_{k}=s_{j}\right \}

为什么刘汝佳哥哥把区间dp，归为了递推？貌似所谓的动态规划在大佬眼里就是简单的递推？万物皆递推，万物皆暴力。

区间DP复杂度好像一般都是O(n^{3}) 啊，有明显的阶段，左端点，右端点，决策呀。

代码（递归，记忆化搜索）：

# define _CRT_SECURE_NO_WARNINGS
#pragma GCC optimize(2)
//#include <bits/stdc++.h>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <vector>
#define inf 0x3f3f3f3f
#define Pair pair<int,int>
//#define int long long
#define fir first
#define sec second
namespace fastIO {
#define BUF_SIZE 100000
#define OUT_SIZE 100000
  //fread->read
  bool IOerror = 0;
  //inline char nc(){char ch=getchar();if(ch==-1)IOerror=1;return ch;}
  inline char nc() {
    static char buf[BUF_SIZE], * p1 = buf + BUF_SIZE, * pend = buf + BUF_SIZE;
    if (p1 == pend) {
      p1 = buf; pend = buf + fread(buf, 1, BUF_SIZE, stdin);
      if (pend == p1) { IOerror = 1; return -1; }
    }
    return *p1++;
  }
  inline bool blank(char ch) { return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t'; }
  template<class T> inline bool read(T& x) {
    bool sign = 0; char ch = nc(); x = 0;
    for (; blank(ch); ch = nc());
    if (IOerror)return false;
    if (ch == '-')sign = 1, ch = nc();
    for (; ch >= '0' && ch <= '9'; ch = nc())x = x * 10 + ch - '0';
    if (sign)x = -x;
    return true;
  }
  inline bool read(double& x) {
    bool sign = 0; char ch = nc(); x = 0;
    for (; blank(ch); ch = nc());
    if (IOerror)return false;
    if (ch == '-')sign = 1, ch = nc();
    for (; ch >= '0' && ch <= '9'; ch = nc())x = x * 10 + ch - '0';
    if (ch == '.') { double tmp = 1; ch = nc(); for (; ch >= '0' && ch <= '9'; ch = nc())tmp /= 10.0, x += tmp * (ch - '0'); }
    if (sign)x = -x; return true;
  }
  inline bool read(char* s) {
    char ch = nc();
    for (; blank(ch); ch = nc());
    if (IOerror)return false;
    for (; !blank(ch) && !IOerror; ch = nc())* s++ = ch;
    *s = 0;
    return true;
  }
  inline bool read(char& c) {
    for (c = nc(); blank(c); c = nc());
    if (IOerror) { c = -1; return false; }
    return true;
  }
  template<class T, class... U>bool read(T& h, U& ... t) { return read(h) && read(t...); }
#undef OUT_SIZE
#undef BUF_SIZE
};
using namespace fastIO;
using namespace std;


/*---------------------------------------------------------------------------------------------------------------------------*/
const double eps = 1e-8;
struct Point { double x, y; Point(double x = 0, double y = 0) :x(x), y(y) {} };
typedef Point Vector;
Vector operator + (Vector A, Vector B) { return Vector(A.x + B.x, A.y + B.y); }
Vector operator - (Point A, Point B) { return Vector(A.x - B.x, A.y - B.y); }
Vector operator * (Vector A, double p) { return Vector(A.x * p, A.y * p); }
Vector operator / (Vector A, double p) { return Vector(A.x / p, A.y / p); }
bool operator < (const Point& A, const Point& B) { return A.x < B.x || (A.x == B.x && A.y < B.y); }
int dcmp(double x) { if (fabs(x) < eps)return 0; else return x < 0 ? -1 : 1; }
bool operator == (const Point& A, const Point& B) { return dcmp(A.x - B.x) == 0 && dcmp(A.y - B.y) == 0; }
double Dot(Vector A, Vector B) { return A.x * B.x + A.y * B.y; }
double Length(Vector A) { return sqrt(Dot(A, A)); }
double Dist2(const Point& A, const Point& B) { return (A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y); }
double Angle(Vector A, Vector B) { return acos(Dot(A, B) / Length(A) / Length(B)); }
double Cross(Vector A, Vector B) { return A.x * B.y - A.y * B.x; }
double Area2(Point A, Point B, Point C) { return Cross(B - A, C - A); }
double DistanceToLine(Point P, Point A, Point B) { Vector v1 = B - A, v2 = P - A; return fabs(Cross(v1, v2)) / Length(v1); }
Vector Normal(Vector A) { double L = Length(A); return Vector(-A.y / L, A.x / L); }
Vector Rotate(Vector A, double rad) { return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad)); }
Point GetLineIntersection(Point P, Vector v, Point Q, Vector w) { Vector u = P - Q; double t = Cross(w, u) / Cross(v, w); return P + v * t; }
double PolygonArea(vector<Point>p) {//duo area
  double area = 0;
  int n = p.size();
  for (int i = 1; i < n - 1; i++)area += Cross(p[i] - p[0], p[i + 1] - p[0]);
  return area / 2;
}
double torad(double deg) { return deg / 180 * acos(-1); }
vector<Point> ConvexHull(vector<Point>& p) {
  sort(p.begin(), p.end());
  p.erase(unique(p.begin(), p.end()), p.end());
  int n = p.size();
  int m = 0;
  vector<Point> ch(n + 1);
  for (int i = 0; i < n; i++) { while (m > 1 && Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0)m--; ch[m++] = p[i]; }
  int k = m;
  for (int i = n - 2; i >= 0; i--) { while (m > k && Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0)m--; ch[m++] = p[i]; }
  if (n > 1)m--;
  ch.resize(m);
  return ch;
}
double diameter2(vector<Point>& points, Point& A, Point& B) {
  vector<Point>p = ConvexHull(points);
  int n = p.size();
  if (n == 1) return 0;
  if (n == 2) return Dist2(p[0], p[1]);
  //p.push_back(p[0]); // 免得取模
  double ans = 0;
  for (int u = 0, v = 1; u < n; u++) {
    for (;;) {
      //Cross(p[u+1]-p[u],p[v+1]-p[v])<=0时停止旋转
      int diff = Cross(p[u + 1] - p[u], p[v + 1] - p[v]);
      if (diff <= 0) {
        if (Dist2(p[u], p[v]) > ans) {
          ans = Dist2(p[u], p[v]); // u和v是对踵点
          A = p[u]; B = p[v];
        }
        //if(diff==0) ans=max(ans,Dist2(p[u],p[v+1])); // diff==0 时u和v+1也是对踵点
        break;
      }
      v = (v + 1) % n;
    }
  }
  return ans;
}
/*---------------------------------------------------------------------------------------------------------------------------*/
struct Line {
  Point P;
  Vector v;
  double ang;
  Line() {}
  Line(Point P, Vector v) :P(P), v(v) { ang = atan2(v.y, v.x); }
  bool operator < (const Line& L)const {
    return ang < L.ang;
  }
};
Point GetLineIntersection(const Line& a, const Line& b) {
  Vector u = a.P - b.P;
  double t = Cross(b.v, u) / Cross(a.v, b.v);
  return a.P + a.v * t;
}
bool OnLeft(Line L, Point p) { return Cross(L.v, p - L.P) > 0; }
vector<Point>HalfplaneIntersection(vector<Line>L) {
  int n = L.size();
  sort(L.begin(), L.end());
  int first, last;
  vector<Point> p(n);
  vector<Line> q(n);
  vector<Point> ans;
  q[first = last = 0] = L[0];
  for (int i = 1; i < n; i++) {
    while (first < last && !OnLeft(L[i], p[last - 1])) last--;
    while (first < last && !OnLeft(L[i], p[first]))first++;
    q[++last] = L[i];
    if (fabs(Cross(q[last].v, q[last - 1].v)) < eps) {
      last--;
      if (OnLeft(q[last], L[i].P))q[last] = L[i];
    }
    if (first < last)p[last - 1] = GetLineIntersection(q[last - 1], q[last]);
  }
  while (first < last && !OnLeft(q[first], p[last - 1]))last--;//删除无用平面
  if (last - first <= 1)return ans;
  p[last] = GetLineIntersection(q[last], q[first]);//计算首尾两个半平面的交点
  //从deque复制到输出中
  for (int i = first; i <= last; i++)ans.push_back(p[i]);
  return ans;
}
bool OnSegment(const Point& p, const Point& a1, const Point& a2) {
  return dcmp(Cross(a1 - p, a2 - p)) == 0 && dcmp(Dot(a1 - p, a2 - p)) < 0;
}
bool SegmentProperIntersection(const Point& a1, const Point& a2, const Point& b1, const Point& b2) {
  double c1 = Cross(a2 - a1, b1 - a1), c2 = Cross(a2 - a1, b2 - a1),
    c3 = Cross(b2 - b1, a1 - b1), c4 = Cross(b2 - b1, a2 - b1);
  return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0;
}
int IsPointInPolygon(const Point& p, const vector<Point>& poly) {
  int wn = 0;
  int n = poly.size();
  for (int i = 0; i < n; i++) {
    const Point& p1 = poly[i];
    const Point& p2 = poly[(i + 1) % n];
    if (p1 == p || p2 == p || OnSegment(p, p1, p2)) return -1; // 在边界上
    int k = dcmp(Cross(p2 - p1, p - p1));
    int d1 = dcmp(p1.y - p.y);
    int d2 = dcmp(p2.y - p.y);
    if (k > 0 && d1 <= 0 && d2 > 0) wn++;
    if (k < 0 && d2 <= 0 && d1 > 0) wn--;
  }
  if (wn != 0) return 1; // 内部
  return 0; // 外部
}

bool ConvexPolygonDisjoint(const vector<Point> ch1, const vector<Point> ch2) {
  int c1 = ch1.size();
  int c2 = ch2.size();
  cout << "c1 " << c1 << " " << "c2 " << c2 << endl;
  for (int i = 0; i < c1; i++)
    if (IsPointInPolygon(ch1[i], ch2) != 0) return false; // 内部或边界上
  for (int i = 0; i < c2; i++)
    if (IsPointInPolygon(ch2[i], ch1) != 0) return false; // 内部或边界上
  for (int i = 0; i < c1; i++)
    for (int j = 0; j < c2; j++)
      if (SegmentProperIntersection(ch1[i], ch1[(i + 1) % c1], ch2[j], ch2[(j + 1) % c2])) return false;
  return true;
}
/*---------------------------------------------------------------------------------------------------------------------------*/

const int N = 1e5 + 5;
const double pi = acos(-1.0);
typedef long long ll;
//const int mod = 998244353;
const int mod = 1e9;

int f[305][305];
char str[N];

int dp(int l, int r) {
  if (str[l] != str[r])return 0;
  if (l == r)return 1;
  if (f[l][r] != -1)return f[l][r];
  f[l][r] = 0;
  /*1 2 3 4*/
  for (int k = l + 2; k <= r; k++)
    f[l][r] = (f[l][r] + (long long)dp(l + 1, k - 1) * dp(k, r)) % mod;
  return f[l][r];
}
signed main() {
  while (scanf("%s", str) == 1) {
    memset(f, -1, sizeof f);
    int len = strlen(str);
    printf("%d\n", dp(0, len - 1)%mod);
  }

  return 0;
}

代码（一般递推）：

# define _CRT_SECURE_NO_WARNINGS
#pragma GCC optimize(2)
//#include <bits/stdc++.h>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <vector>
#define inf 0x3f3f3f3f
#define Pair pair<int,int>
//#define int long long
#define fir first
#define sec second
namespace fastIO {
#define BUF_SIZE 100000
#define OUT_SIZE 100000
  //fread->read
  bool IOerror = 0;
  //inline char nc(){char ch=getchar();if(ch==-1)IOerror=1;return ch;}
  inline char nc() {
    static char buf[BUF_SIZE], * p1 = buf + BUF_SIZE, * pend = buf + BUF_SIZE;
    if (p1 == pend) {
      p1 = buf; pend = buf + fread(buf, 1, BUF_SIZE, stdin);
      if (pend == p1) { IOerror = 1; return -1; }
    }
    return *p1++;
  }
  inline bool blank(char ch) { return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t'; }
  template<class T> inline bool read(T& x) {
    bool sign = 0; char ch = nc(); x = 0;
    for (; blank(ch); ch = nc());
    if (IOerror)return false;
    if (ch == '-')sign = 1, ch = nc();
    for (; ch >= '0' && ch <= '9'; ch = nc())x = x * 10 + ch - '0';
    if (sign)x = -x;
    return true;
  }
  inline bool read(double& x) {
    bool sign = 0; char ch = nc(); x = 0;
    for (; blank(ch); ch = nc());
    if (IOerror)return false;
    if (ch == '-')sign = 1, ch = nc();
    for (; ch >= '0' && ch <= '9'; ch = nc())x = x * 10 + ch - '0';
    if (ch == '.') { double tmp = 1; ch = nc(); for (; ch >= '0' && ch <= '9'; ch = nc())tmp /= 10.0, x += tmp * (ch - '0'); }
    if (sign)x = -x; return true;
  }
  inline bool read(char* s) {
    char ch = nc();
    for (; blank(ch); ch = nc());
    if (IOerror)return false;
    for (; !blank(ch) && !IOerror; ch = nc())* s++ = ch;
    *s = 0;
    return true;
  }
  inline bool read(char& c) {
    for (c = nc(); blank(c); c = nc());
    if (IOerror) { c = -1; return false; }
    return true;
  }
  template<class T, class... U>bool read(T& h, U& ... t) { return read(h) && read(t...); }
#undef OUT_SIZE
#undef BUF_SIZE
};
using namespace fastIO;
using namespace std;


/*---------------------------------------------------------------------------------------------------------------------------*/
const double eps = 1e-8;
struct Point { double x, y; Point(double x = 0, double y = 0) :x(x), y(y) {} };
typedef Point Vector;
Vector operator + (Vector A, Vector B) { return Vector(A.x + B.x, A.y + B.y); }
Vector operator - (Point A, Point B) { return Vector(A.x - B.x, A.y - B.y); }
Vector operator * (Vector A, double p) { return Vector(A.x * p, A.y * p); }
Vector operator / (Vector A, double p) { return Vector(A.x / p, A.y / p); }
bool operator < (const Point& A, const Point& B) { return A.x < B.x || (A.x == B.x && A.y < B.y); }
int dcmp(double x) { if (fabs(x) < eps)return 0; else return x < 0 ? -1 : 1; }
bool operator == (const Point& A, const Point& B) { return dcmp(A.x - B.x) == 0 && dcmp(A.y - B.y) == 0; }
double Dot(Vector A, Vector B) { return A.x * B.x + A.y * B.y; }
double Length(Vector A) { return sqrt(Dot(A, A)); }
double Dist2(const Point& A, const Point& B) { return (A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y); }
double Angle(Vector A, Vector B) { return acos(Dot(A, B) / Length(A) / Length(B)); }
double Cross(Vector A, Vector B) { return A.x * B.y - A.y * B.x; }
double Area2(Point A, Point B, Point C) { return Cross(B - A, C - A); }
double DistanceToLine(Point P, Point A, Point B) { Vector v1 = B - A, v2 = P - A; return fabs(Cross(v1, v2)) / Length(v1); }
Vector Normal(Vector A) { double L = Length(A); return Vector(-A.y / L, A.x / L); }
Vector Rotate(Vector A, double rad) { return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad)); }
Point GetLineIntersection(Point P, Vector v, Point Q, Vector w) { Vector u = P - Q; double t = Cross(w, u) / Cross(v, w); return P + v * t; }
double PolygonArea(vector<Point>p) {//duo area
  double area = 0;
  int n = p.size();
  for (int i = 1; i < n - 1; i++)area += Cross(p[i] - p[0], p[i + 1] - p[0]);
  return area / 2;
}
double torad(double deg) { return deg / 180 * acos(-1); }
vector<Point> ConvexHull(vector<Point>& p) {
  sort(p.begin(), p.end());
  p.erase(unique(p.begin(), p.end()), p.end());
  int n = p.size();
  int m = 0;
  vector<Point> ch(n + 1);
  for (int i = 0; i < n; i++) { while (m > 1 && Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0)m--; ch[m++] = p[i]; }
  int k = m;
  for (int i = n - 2; i >= 0; i--) { while (m > k && Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2]) <= 0)m--; ch[m++] = p[i]; }
  if (n > 1)m--;
  ch.resize(m);
  return ch;
}
double diameter2(vector<Point>& points, Point& A, Point& B) {
  vector<Point>p = ConvexHull(points);
  int n = p.size();
  if (n == 1) return 0;
  if (n == 2) return Dist2(p[0], p[1]);
  //p.push_back(p[0]); // 免得取模
  double ans = 0;
  for (int u = 0, v = 1; u < n; u++) {
    for (;;) {
      //Cross(p[u+1]-p[u],p[v+1]-p[v])<=0时停止旋转
      int diff = Cross(p[u + 1] - p[u], p[v + 1] - p[v]);
      if (diff <= 0) {
        if (Dist2(p[u], p[v]) > ans) {
          ans = Dist2(p[u], p[v]); // u和v是对踵点
          A = p[u]; B = p[v];
        }
        //if(diff==0) ans=max(ans,Dist2(p[u],p[v+1])); // diff==0 时u和v+1也是对踵点
        break;
      }
      v = (v + 1) % n;
    }
  }
  return ans;
}
/*---------------------------------------------------------------------------------------------------------------------------*/
struct Line {
  Point P;
  Vector v;
  double ang;
  Line() {}
  Line(Point P, Vector v) :P(P), v(v) { ang = atan2(v.y, v.x); }
  bool operator < (const Line& L)const {
    return ang < L.ang;
  }
};
Point GetLineIntersection(const Line& a, const Line& b) {
  Vector u = a.P - b.P;
  double t = Cross(b.v, u) / Cross(a.v, b.v);
  return a.P + a.v * t;
}
bool OnLeft(Line L, Point p) { return Cross(L.v, p - L.P) > 0; }
vector<Point>HalfplaneIntersection(vector<Line>L) {
  int n = L.size();
  sort(L.begin(), L.end());
  int first, last;
  vector<Point> p(n);
  vector<Line> q(n);
  vector<Point> ans;
  q[first = last = 0] = L[0];
  for (int i = 1; i < n; i++) {
    while (first < last && !OnLeft(L[i], p[last - 1])) last--;
    while (first < last && !OnLeft(L[i], p[first]))first++;
    q[++last] = L[i];
    if (fabs(Cross(q[last].v, q[last - 1].v)) < eps) {
      last--;
      if (OnLeft(q[last], L[i].P))q[last] = L[i];
    }
    if (first < last)p[last - 1] = GetLineIntersection(q[last - 1], q[last]);
  }
  while (first < last && !OnLeft(q[first], p[last - 1]))last--;//删除无用平面
  if (last - first <= 1)return ans;
  p[last] = GetLineIntersection(q[last], q[first]);//计算首尾两个半平面的交点
  //从deque复制到输出中
  for (int i = first; i <= last; i++)ans.push_back(p[i]);
  return ans;
}
bool OnSegment(const Point& p, const Point& a1, const Point& a2) {
  return dcmp(Cross(a1 - p, a2 - p)) == 0 && dcmp(Dot(a1 - p, a2 - p)) < 0;
}
bool SegmentProperIntersection(const Point& a1, const Point& a2, const Point& b1, const Point& b2) {
  double c1 = Cross(a2 - a1, b1 - a1), c2 = Cross(a2 - a1, b2 - a1),
    c3 = Cross(b2 - b1, a1 - b1), c4 = Cross(b2 - b1, a2 - b1);
  return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0;
}
int IsPointInPolygon(const Point& p, const vector<Point>& poly) {
  int wn = 0;
  int n = poly.size();
  for (int i = 0; i < n; i++) {
    const Point& p1 = poly[i];
    const Point& p2 = poly[(i + 1) % n];
    if (p1 == p || p2 == p || OnSegment(p, p1, p2)) return -1; // 在边界上
    int k = dcmp(Cross(p2 - p1, p - p1));
    int d1 = dcmp(p1.y - p.y);
    int d2 = dcmp(p2.y - p.y);
    if (k > 0 && d1 <= 0 && d2 > 0) wn++;
    if (k < 0 && d2 <= 0 && d1 > 0) wn--;
  }
  if (wn != 0) return 1; // 内部
  return 0; // 外部
}

bool ConvexPolygonDisjoint(const vector<Point> ch1, const vector<Point> ch2) {
  int c1 = ch1.size();
  int c2 = ch2.size();
  cout << "c1 " << c1 << " " << "c2 " << c2 << endl;
  for (int i = 0; i < c1; i++)
    if (IsPointInPolygon(ch1[i], ch2) != 0) return false; // 内部或边界上
  for (int i = 0; i < c2; i++)
    if (IsPointInPolygon(ch2[i], ch1) != 0) return false; // 内部或边界上
  for (int i = 0; i < c1; i++)
    for (int j = 0; j < c2; j++)
      if (SegmentProperIntersection(ch1[i], ch1[(i + 1) % c1], ch2[j], ch2[(j + 1) % c2])) return false;
  return true;
}
/*---------------------------------------------------------------------------------------------------------------------------*/

const int N = 1e5 + 5;
const double pi = acos(-1.0);
typedef long long ll;
//const int mod = 998244353;
const int mod = 1e9;

int f[305][305];
char str[N];

signed main() {
  while (scanf("%s", str) == 1) {
    memset(f, -1, sizeof f);
    int slen = strlen(str);
    for (int i = 0; i < slen; i++)f[i][i] = 1;
    for (int len = 1; len < slen; len++) {//阶段
      for (int l = 0; l + len < slen; l++) {//左断点
        int r = l + len;//右端点
        f[l][r] = 0;
        if (str[l] == str[r] && (r - l + 1 & 1)) {//子树序列必然为奇数
          f[l][r] = f[l + 1][r - 1];
          //printf("%d %d %d\n", l, r, f[l + 1][r - 1]);
          for (int k = l + 2; k < r; k++) {//决策
            f[l][r] = (f[l][r] + f[l + 1][k - 1] * f[k][r]) % mod;
          }
        }
      }

    }
    printf("%d\n", f[0][slen - 1]);
  }

  //printf("%d\n", 2 & 1);

  return 0;
}

 

Qo0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ 2795/LA3516-Exploring Pyramids - dp
缺氧
10-29 486
http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=27284 题意： 给出一颗多叉树的按照 中序遍历结果（先左边,走到尽头后沿路返回跟，再往右边走） 请问有多少种树满足这个遍历序列 ;如ABABABA有以下5种可能 给出序列为 S[] dp[i][j]表示 从i到j 的一段自序列对应的树的个数 那
LA 3516 Exploring Pyramids (记忆化搜索)
weixin_30362233的博客
08-09 80
题意 给定一个DFS序列，问能有多少树与之对应。 思路 设输入序列为S，dp(i, j)为子序列Si, Si+1, ……, Sj对应的树的个数，则边界条件为d(i, i) = 1，且Si != Sj时d(i, j) = 0（因为起点和终点应该是同一个点）。在其他情况下，设第一个分支在Sk时回到树根（必须有Si == Sk），则这个分支对应的序列是Si+1, Si+2, …… , Sk-1，方案数为...
contest hunter5302（dp）
a1035719430的博客
09-06 249
描述 虽然探索金字塔是极其老套的剧情，但是有一队探险家还是到了某金字塔脚下。经过多年的研究，科学家对这座金字塔的内部结构已经有所了解。首先，金字塔由若干房间组成，房间之间连有通道。如果把房间看作节点，通道看作边的话，整个金字塔呈现一个有根树结构，节点的子树之间有序，金字塔有唯一的一个入口通向树根。并且，每个房间的墙壁都涂有若干种颜色的一种。 探险队员打算进一步了解金字塔的结构，为...
Exploring Pyramids UVALive - 3516 (记忆化DP)
babing2770的博客
07-17 106
题意：给定一个序列 问有多少棵树与之对应 题目连接：https://cn.vjudge.net/problem/UVALive-3516 对于这一序列 分两种2情况 当前分支 和 其它分支 用dfs 在当前层的dfs 只讨论当前分支 其他分支 dfs到下一层 构成分支的条件 即为str[i] == str[j] 即首和末相同 然后再去判断着一串上的其它字母 是否符合回溯的条件...
UVa1362 Exploring Pyramids
sunshinezff的专栏
03-14 459
UVa1362 Exploring Pyramids(树形dp）       Archaeologists have discovered a new set of hidden caves in one of the Egyptian pyramids. The decryption of ancient hieroglyphs on the walls nearby showed t
Arduino-Exploring-Arduino-1st-Edition.zip
09-18
Arduino-Exploring-Arduino-1st-Edition.zip,Jeremy Blumemexploring Arduino的书《探索Arduino》第一版的配套代码：第一版,Arduino是一家开源软硬件公司和制造商社区。Arduino始于21世纪初，深受电子制造商的欢迎，...
EXPLORING-THE-JUNOS-CLI.rar_PDF_
08-11
《EXPLORING-THE-JUNOS-CLI.rar_PDF_》这个压缩包文件主要包含了一份关于“一天探索Junos CLI”的PDF文档，名为“EXPLORING THE JUNOS CLI.pdf”。这份文档旨在帮助读者深入理解并熟练掌握Juniper Networks的JunOS...
Exploring-Transformer-Basics.pdf
07-02
transformer
Exploring-Mathematics-with-MuPAD_MTManual10.rar_matlab例程_matlab_
08-11
"Exploring Mathematics with MuPAD_MTManual10.pdf"是这份教程的详细手册，涵盖了从基础操作到高级应用的所有内容。用户可以通过阅读此手册，深入学习如何在MATLAB中有效地使用MuPAD进行数学探索和计算。 总结来说...
Exploring ES6 - Dr. Axel Rauschmayer.epub
11-22
这是一本精通javascript的好书,在原版基础上,订正了一些拼写错误.
1362 - Exploring Pyramids
懒人一枚。
09-15 833
#include #include #include #include using namespace std; typedef long long ll; const int MOD = 1000000000; const int MAXN = 305; char s[MAXN]; ll d[MAXN][MAXN]; ll dp(int i, int j) { if (
Exploring Pyramids UVA - 1362
海绵的博客
08-12 219
#include&lt;bits/stdc++.h&gt; using namespace std; #define rep(i,a,b) for(int i=a;i&lt;b;i++) typedef long long ll; bool is_prime(int x){if(x&lt;2)return false;int m=sqrt(x+0.5);rep(i,2,m+1)if(x%i...
UVALive - 3516 Exploring Pyramids
那些年
02-14 1072
题意：给你一棵多叉树，每个节点的任意两个子节点都有左右之分，从根节点开始尽量往左走，走不通就回溯，把遇到的字母记录下来，可以得到一个序列，给定一个序列，问有 多少棵树与之相应 思路：当sk=si的时候代表回溯到了树根了，那么分支的序列就是si+1,...sk-1，那么就可以设方案数d(i,j)以及它的分支方案数d(i+1,k-1),可以推出关系d(i,j)=sum{d(i+1.k-1)*d(k
【LA3516】Exploring Pyramids——动态规划+乘法原理
绝尘
03-28 707
Archaeologists have discovered a new set of hidden caves in one of the Egyptian pyramids. The decryption of ancient hieroglyphs on the walls nearby showed that the caves structure is as follows. Ther
uva 1362 - Exploring Pyramids(区间dp)
不慌不忙、不急不躁
05-18 1662
题目连接:uva 1362 - Exploring Pyramids 题目大意：给出一个字符串，问有多少种多叉树德前序遍历（这里每经过一个节点，该节点的值即要被算入，回溯的也要）满足该字符串。 解题思路：dp[i][j]表示从i到j的位置可以用多少种多叉树表示。转移方程：dp[i][j]=∑k=i+2jdp[i+1][k−1]∗dp[k][j]。 #include #include
poj 2795 Exploring Pyramids
To be what you what to be!
01-24 1252
Exploring Pyramids Time Limit: 6000MS   Memory Limit: 65536K Total Submissions: 1971   Accepted: 899 Case Time Limit: 2000MS Description Archaeologists have discover
Exploring Pyramids【动态规划——区间DP】
C++的星空
11-09 198
Exploring Pyramids  UVALive - 3516  题目传送门 题目大意：给你一个字符串，其代表的是机器人来回走过的路径，机器人总是先走左边再走右边，问有多少种情况。 解决方法：设输入序列为S，d(i,j)为子序列Si,Si+1,…,Sj对应的树的个数，则可以发现d(i,i)=1;并且Si不等于Sj时d(i,j)=0(因为起点和终点应该是同一点）。在其他情况下，设第一个...
Exploring Pyramids UVALive - 3516 题解
Sega_hsj 's Blog
03-11 327
Exploring Pyramids UVALive - 3516 题解
工业企业数字化转型通用方案2两个文档.pptx
最新发布
07-05
工业企业数字化转型通用方案2两个文档.pptx
meta-baseline: exploring simple meta-learning for few-shot learning
04-11
《b'meta-baseline: exploring simple meta-learning for few-shot learning'》这篇论文提出了一种简单的元学习方法用于少样本学习，称之为meta-baseline。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值