diff --git a/internal/ceres/array_utils.cc b/internal/ceres/array_utils.cc
index 1501866..8362618 100644
--- a/internal/ceres/array_utils.cc
+++ b/internal/ceres/array_utils.cc
@@ -38,9 +38,8 @@
 
 #include "ceres/stringprintf.h"
 #include "ceres/types.h"
-namespace ceres::internal {
 
-using std::string;
+namespace ceres::internal {
 
 bool IsArrayValid(const int size, const double* x) {
   if (x != nullptr) {
@@ -75,7 +74,7 @@
   }
 }
 
-void AppendArrayToString(const int size, const double* x, string* result) {
+void AppendArrayToString(const int size, const double* x, std::string* result) {
   for (int i = 0; i < size; ++i) {
     if (x == nullptr) {
       StringAppendF(result, "Not Computed  ");
diff --git a/internal/ceres/array_utils_test.cc b/internal/ceres/array_utils_test.cc
index 8a94ec1..5820728 100644
--- a/internal/ceres/array_utils_test.cc
+++ b/internal/ceres/array_utils_test.cc
@@ -38,8 +38,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
-
 TEST(ArrayUtils, IsArrayValid) {
   double x[3];
   x[0] = 0.0;
@@ -75,10 +73,10 @@
 }
 
 TEST(MapValuesToContiguousRange, ContiguousEntries) {
-  vector<int> array;
+  std::vector<int> array;
   array.push_back(0);
   array.push_back(1);
-  vector<int> expected = array;
+  std::vector<int> expected = array;
   MapValuesToContiguousRange(array.size(), &array[0]);
   EXPECT_EQ(array, expected);
   array.clear();
@@ -91,10 +89,10 @@
 }
 
 TEST(MapValuesToContiguousRange, NonContiguousEntries) {
-  vector<int> array;
+  std::vector<int> array;
   array.push_back(0);
   array.push_back(2);
-  vector<int> expected;
+  std::vector<int> expected;
   expected.push_back(0);
   expected.push_back(1);
   MapValuesToContiguousRange(array.size(), &array[0]);
@@ -102,14 +100,14 @@
 }
 
 TEST(MapValuesToContiguousRange, NonContiguousRepeatingEntries) {
-  vector<int> array;
+  std::vector<int> array;
   array.push_back(3);
   array.push_back(1);
   array.push_back(0);
   array.push_back(0);
   array.push_back(0);
   array.push_back(5);
-  vector<int> expected;
+  std::vector<int> expected;
   expected.push_back(2);
   expected.push_back(1);
   expected.push_back(0);
diff --git a/internal/ceres/block_jacobian_writer.cc b/internal/ceres/block_jacobian_writer.cc
index d7e1e95..a481626 100644
--- a/internal/ceres/block_jacobian_writer.cc
+++ b/internal/ceres/block_jacobian_writer.cc
@@ -43,8 +43,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
-
 namespace {
 
 // Given the residual block ordering, build a lookup table to determine which
@@ -59,9 +57,9 @@
 // instead of num_eliminate_blocks.
 void BuildJacobianLayout(const Program& program,
                          int num_eliminate_blocks,
-                         vector<int*>* jacobian_layout,
-                         vector<int>* jacobian_layout_storage) {
-  const vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
+                         std::vector<int*>* jacobian_layout,
+                         std::vector<int>* jacobian_layout_storage) {
+  const std::vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
 
   // Iterate over all the active residual blocks and determine how many E blocks
   // are there. This will determine where the F blocks start in the jacobian
@@ -153,7 +151,7 @@
 std::unique_ptr<SparseMatrix> BlockJacobianWriter::CreateJacobian() const {
   auto* bs = new CompressedRowBlockStructure;
 
-  const vector<ParameterBlock*>& parameter_blocks =
+  const std::vector<ParameterBlock*>& parameter_blocks =
       program_->parameter_blocks();
 
   // Construct the column blocks.
@@ -167,7 +165,7 @@
   }
 
   // Construct the cells in each row.
-  const vector<ResidualBlock*>& residual_blocks = program_->residual_blocks();
+  const std::vector<ResidualBlock*>& residual_blocks = program_->residual_blocks();
   int row_block_position = 0;
   bs->rows.resize(residual_blocks.size());
   for (int i = 0; i < residual_blocks.size(); ++i) {
diff --git a/internal/ceres/bundle_adjustment_test_util.h b/internal/ceres/bundle_adjustment_test_util.h
index 696b39e..68d7a7c 100644
--- a/internal/ceres/bundle_adjustment_test_util.h
+++ b/internal/ceres/bundle_adjustment_test_util.h
@@ -51,9 +51,6 @@
 namespace ceres {
 namespace internal {
 
-using std::string;
-using std::vector;
-
 const bool kAutomaticOrdering = true;
 const bool kUserOrdering = false;
 
@@ -68,7 +65,7 @@
     BuildProblem();
   }
   BundleAdjustmentProblem() {
-    const string input_file = TestFileAbsolutePath("problem-16-22106-pre.txt");
+    const std::string input_file = TestFileAbsolutePath("problem-16-22106-pre.txt");
     ReadData(input_file);
     BuildProblem();
   }
@@ -98,7 +95,7 @@
   static double kResidualTolerance;
 
  private:
-  void ReadData(const string& filename) {
+  void ReadData(const std::string& filename) {
     FILE* fptr = fopen(filename.c_str(), "r");
 
     if (!fptr) {
diff --git a/internal/ceres/callbacks.cc b/internal/ceres/callbacks.cc
index fcdcb2a..b46f62c 100644
--- a/internal/ceres/callbacks.cc
+++ b/internal/ceres/callbacks.cc
@@ -39,8 +39,6 @@
 
 namespace ceres::internal {
 
-using std::string;
-
 StateUpdatingCallback::StateUpdatingCallback(Program* program,
                                              double* parameters)
     : program_(program), parameters_(parameters) {}
@@ -82,7 +80,7 @@
 
 CallbackReturnType LoggingCallback::operator()(
     const IterationSummary& summary) {
-  string output;
+  std::string output;
   if (minimizer_type == LINE_SEARCH) {
     output = StringPrintf(
         "% 4d: f:% 8e d:% 3.2e g:% 3.2e h:% 3.2e s:% 3.2e e:% 3d it:% 3.2e "
diff --git a/internal/ceres/canonical_views_clustering.cc b/internal/ceres/canonical_views_clustering.cc
index 7c385fc..7599f6d 100644
--- a/internal/ceres/canonical_views_clustering.cc
+++ b/internal/ceres/canonical_views_clustering.cc
@@ -41,8 +41,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
-
 using IntMap = std::unordered_map<int, int>;
 using IntSet = std::unordered_set<int>;
 
@@ -58,15 +56,15 @@
   // are assigned to a cluster with id = kInvalidClusterId.
   void ComputeClustering(const CanonicalViewsClusteringOptions& options,
                          const WeightedGraph<int>& graph,
-                         vector<int>* centers,
+                         std::vector<int>* centers,
                          IntMap* membership);
 
  private:
   void FindValidViews(IntSet* valid_views) const;
   double ComputeClusteringQualityDifference(const int candidate,
-                                            const vector<int>& centers) const;
+                                            const std::vector<int>& centers) const;
   void UpdateCanonicalViewAssignments(const int canonical_view);
-  void ComputeClusterMembership(const vector<int>& centers,
+  void ComputeClusterMembership(const std::vector<int>& centers,
                                 IntMap* membership) const;
 
   CanonicalViewsClusteringOptions options_;
@@ -81,7 +79,7 @@
 void ComputeCanonicalViewsClustering(
     const CanonicalViewsClusteringOptions& options,
     const WeightedGraph<int>& graph,
-    vector<int>* centers,
+    std::vector<int>* centers,
     IntMap* membership) {
   time_t start_time = time(nullptr);
   CanonicalViewsClustering cv;
@@ -94,7 +92,7 @@
 void CanonicalViewsClustering::ComputeClustering(
     const CanonicalViewsClusteringOptions& options,
     const WeightedGraph<int>& graph,
-    vector<int>* centers,
+    std::vector<int>* centers,
     IntMap* membership) {
   options_ = options;
   CHECK(centers != nullptr);
@@ -150,7 +148,7 @@
 // Computes the difference in the quality score if 'candidate' were
 // added to the set of canonical views.
 double CanonicalViewsClustering::ComputeClusteringQualityDifference(
-    const int candidate, const vector<int>& centers) const {
+    const int candidate, const std::vector<int>& centers) const {
   // View score.
   double difference =
       options_.view_score_weight * graph_->VertexWeight(candidate);
@@ -197,7 +195,7 @@
 
 // Assign a cluster id to each view.
 void CanonicalViewsClustering::ComputeClusterMembership(
-    const vector<int>& centers, IntMap* membership) const {
+    const std::vector<int>& centers, IntMap* membership) const {
   CHECK(membership != nullptr);
   membership->clear();
 
diff --git a/internal/ceres/coordinate_descent_minimizer.cc b/internal/ceres/coordinate_descent_minimizer.cc
index de22822..cd0caf2 100644
--- a/internal/ceres/coordinate_descent_minimizer.cc
+++ b/internal/ceres/coordinate_descent_minimizer.cc
@@ -51,13 +51,6 @@
 
 namespace ceres::internal {
 
-using std::map;
-using std::max;
-using std::min;
-using std::set;
-using std::string;
-using std::vector;
-
 CoordinateDescentMinimizer::CoordinateDescentMinimizer(ContextImpl* context)
     : context_(context) {
   CHECK(context_ != nullptr);
@@ -69,15 +62,15 @@
     const Program& program,
     const ProblemImpl::ParameterMap& parameter_map,
     const ParameterBlockOrdering& ordering,
-    string* error) {
+    std::string* error) {
   parameter_blocks_.clear();
   independent_set_offsets_.clear();
   independent_set_offsets_.push_back(0);
 
   // Serialize the OrderedGroups into a vector of parameter block
   // offsets for parallel access.
-  map<ParameterBlock*, int> parameter_block_index;
-  map<int, set<double*>> group_to_elements = ordering.group_to_elements();
+  std::map<ParameterBlock*, int> parameter_block_index;
+  std::map<int, std::set<double*>> group_to_elements = ordering.group_to_elements();
   for (const auto& g_t_e : group_to_elements) {
     const auto& elements = g_t_e.second;
     for (double* parameter_block : elements) {
@@ -92,7 +85,7 @@
   // The ordering does not have to contain all parameter blocks, so
   // assign zero offsets/empty independent sets to these parameter
   // blocks.
-  const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+  const std::vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
   for (auto* parameter_block : parameter_blocks) {
     if (!ordering.IsMember(parameter_block->mutable_user_state())) {
       parameter_blocks_.push_back(parameter_block);
@@ -103,7 +96,7 @@
   // Compute the set of residual blocks that depend on each parameter
   // block.
   residual_blocks_.resize(parameter_block_index.size());
-  const vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
+  const std::vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
   for (auto* residual_block : residual_blocks) {
     const int num_parameter_blocks = residual_block->NumParameterBlocks();
     for (int j = 0; j < num_parameter_blocks; ++j) {
@@ -152,9 +145,9 @@
     }
 
     const int num_inner_iteration_threads =
-        min(options.num_threads, num_problems);
+        std::min(options.num_threads, num_problems);
     evaluator_options_.num_threads =
-        max(1, options.num_threads / num_inner_iteration_threads);
+        std::max(1, options.num_threads / num_inner_iteration_threads);
 
     // The parameter blocks in each independent set can be optimized
     // in parallel, since they do not co-occur in any residual block.
@@ -214,7 +207,7 @@
   summary->initial_cost = 0.0;
   summary->fixed_cost = 0.0;
   summary->final_cost = 0.0;
-  string error;
+  std::string error;
 
   Minimizer::Options minimizer_options;
   minimizer_options.evaluator =
@@ -237,8 +230,8 @@
 bool CoordinateDescentMinimizer::IsOrderingValid(
     const Program& program,
     const ParameterBlockOrdering& ordering,
-    string* message) {
-  const map<int, set<double*>>& group_to_elements =
+    std::string* message) {
+  const std::map<int, std::set<double*>>& group_to_elements =
       ordering.group_to_elements();
 
   // Verify that each group is an independent set
diff --git a/internal/ceres/cost_function_to_functor_test.cc b/internal/ceres/cost_function_to_functor_test.cc
index f26fc1d..cf4a57b 100644
--- a/internal/ceres/cost_function_to_functor_test.cc
+++ b/internal/ceres/cost_function_to_functor_test.cc
@@ -40,7 +40,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
 const double kTolerance = 1e-18;
 
 static void ExpectCostFunctionsAreEqual(
@@ -49,9 +48,9 @@
   EXPECT_EQ(cost_function.num_residuals(),
             actual_cost_function.num_residuals());
   const int num_residuals = cost_function.num_residuals();
-  const vector<int32_t>& parameter_block_sizes =
+  const std::vector<int32_t>& parameter_block_sizes =
       cost_function.parameter_block_sizes();
-  const vector<int32_t>& actual_parameter_block_sizes =
+  const std::vector<int32_t>& actual_parameter_block_sizes =
       actual_cost_function.parameter_block_sizes();
   EXPECT_EQ(parameter_block_sizes.size(), actual_parameter_block_sizes.size());
 
diff --git a/internal/ceres/covariance.cc b/internal/ceres/covariance.cc
index 029f3f5..b24999d 100644
--- a/internal/ceres/covariance.cc
+++ b/internal/ceres/covariance.cc
@@ -39,9 +39,6 @@
 
 namespace ceres {
 
-using std::pair;
-using std::vector;
-
 Covariance::Covariance(const Covariance::Options& options) {
   impl_ = std::make_unique<internal::CovarianceImpl>(options);
 }
@@ -49,12 +46,12 @@
 Covariance::~Covariance() = default;
 
 bool Covariance::Compute(
-    const vector<pair<const double*, const double*>>& covariance_blocks,
+    const std::vector<std::pair<const double*, const double*>>& covariance_blocks,
     Problem* problem) {
   return impl_->Compute(covariance_blocks, problem->mutable_impl());
 }
 
-bool Covariance::Compute(const vector<const double*>& parameter_blocks,
+bool Covariance::Compute(const std::vector<const double*>& parameter_blocks,
                          Problem* problem) {
   return impl_->Compute(parameter_blocks, problem->mutable_impl());
 }
@@ -79,7 +76,7 @@
 }
 
 bool Covariance::GetCovarianceMatrix(
-    const vector<const double*>& parameter_blocks,
+    const std::vector<const double*>& parameter_blocks,
     double* covariance_matrix) const {
   return impl_->GetCovarianceMatrixInTangentOrAmbientSpace(parameter_blocks,
                                                            true,  // ambient
diff --git a/internal/ceres/covariance_impl.cc b/internal/ceres/covariance_impl.cc
index 5d8b87f..4245e43 100644
--- a/internal/ceres/covariance_impl.cc
+++ b/internal/ceres/covariance_impl.cc
@@ -59,8 +59,6 @@
 
 namespace ceres::internal {
 
-using std::swap;
-
 using CovarianceBlocks = std::vector<std::pair<const double*, const double*>>;
 
 CovarianceImpl::CovarianceImpl(const Covariance::Options& options)
@@ -166,7 +164,7 @@
   const double* parameter_block2 = original_parameter_block2;
   const bool transpose = parameter_block1 > parameter_block2;
   if (transpose) {
-    swap(parameter_block1, parameter_block2);
+    std::swap(parameter_block1, parameter_block2);
   }
 
   // Find where in the covariance matrix the block is located.
diff --git a/internal/ceres/covariance_test.cc b/internal/ceres/covariance_test.cc
index 76fcb12..7d477a7 100644
--- a/internal/ceres/covariance_test.cc
+++ b/internal/ceres/covariance_test.cc
@@ -50,11 +50,6 @@
 namespace ceres {
 namespace internal {
 
-using std::make_pair;
-using std::map;
-using std::pair;
-using std::vector;
-
 class UnaryCostFunction : public CostFunction {
  public:
   UnaryCostFunction(const int num_residuals,
@@ -84,7 +79,7 @@
   }
 
  private:
-  vector<double> jacobian_;
+  std::vector<double> jacobian_;
 };
 
 class BinaryCostFunction : public CostFunction {
@@ -126,8 +121,8 @@
   }
 
  private:
-  vector<double> jacobian1_;
-  vector<double> jacobian2_;
+  std::vector<double> jacobian1_;
+  std::vector<double> jacobian2_;
 };
 
 TEST(CovarianceImpl, ComputeCovarianceSparsity) {
@@ -184,7 +179,7 @@
                          6, 7, 8, 9};
   // clang-format on
 
-  vector<pair<const double*, const double*>> covariance_blocks;
+  std::vector<std::pair<const double*, const double*>> covariance_blocks;
   covariance_blocks.emplace_back(block1, block1);
   covariance_blocks.emplace_back(block4, block4);
   covariance_blocks.emplace_back(block2, block2);
@@ -265,7 +260,7 @@
                          3, 4, 5, 6};
   // clang-format on
 
-  vector<pair<const double*, const double*>> covariance_blocks;
+  std::vector<std::pair<const double*, const double*>> covariance_blocks;
   covariance_blocks.emplace_back(block1, block1);
   covariance_blocks.emplace_back(block4, block4);
   covariance_blocks.emplace_back(block2, block2);
@@ -344,7 +339,7 @@
                          3, 4, 5, 6};
   // clang-format on
 
-  vector<pair<const double*, const double*>> covariance_blocks;
+  std::vector<std::pair<const double*, const double*>> covariance_blocks;
   covariance_blocks.emplace_back(block1, block1);
   covariance_blocks.emplace_back(block4, block4);
   covariance_blocks.emplace_back(block2, block2);
@@ -409,7 +404,7 @@
 
 class CovarianceTest : public ::testing::Test {
  protected:
-  using BoundsMap = map<const double*, pair<int, int>>;
+  using BoundsMap = std::map<const double*, std::pair<int, int>>;
 
   void SetUp() override {
     double* x = parameters_;
@@ -462,9 +457,9 @@
     all_covariance_blocks_.emplace_back(x, z);
     all_covariance_blocks_.emplace_back(y, z);
 
-    column_bounds_[x] = make_pair(0, 2);
-    column_bounds_[y] = make_pair(2, 5);
-    column_bounds_[z] = make_pair(5, 6);
+    column_bounds_[x] = std::make_pair(0, 2);
+    column_bounds_[y] = std::make_pair(2, 5);
+    column_bounds_[z] = std::make_pair(5, 6);
   }
 
   // Computes covariance in ambient space.
@@ -492,7 +487,7 @@
     // Generate all possible combination of block pairs and check if the
     // covariance computation is correct.
     for (int i = 0; i <= 64; ++i) {
-      vector<pair<const double*, const double*>> covariance_blocks;
+      std::vector<std::pair<const double*, const double*>> covariance_blocks;
       if (i & 1) {
         covariance_blocks.push_back(all_covariance_blocks_[0]);
       }
@@ -585,7 +580,7 @@
 
   double parameters_[6];
   Problem problem_;
-  vector<pair<const double*, const double*>> all_covariance_blocks_;
+  std::vector<std::pair<const double*, const double*>> all_covariance_blocks_;
   BoundsMap column_bounds_;
   BoundsMap local_column_bounds_;
 };
@@ -746,7 +741,7 @@
 
   problem_.SetManifold(x, new PolynomialManifold);
 
-  vector<int> subset;
+  std::vector<int> subset;
   subset.push_back(2);
   problem_.SetManifold(y, new SubsetManifold(3, subset));
 
@@ -806,13 +801,13 @@
 
   problem_.SetManifold(x, new PolynomialManifold);
 
-  vector<int> subset;
+  std::vector<int> subset;
   subset.push_back(2);
   problem_.SetManifold(y, new SubsetManifold(3, subset));
 
-  local_column_bounds_[x] = make_pair(0, 1);
-  local_column_bounds_[y] = make_pair(1, 3);
-  local_column_bounds_[z] = make_pair(3, 4);
+  local_column_bounds_[x] = std::make_pair(0, 1);
+  local_column_bounds_[y] = std::make_pair(1, 3);
+  local_column_bounds_[z] = std::make_pair(3, 4);
 
   // Raw Jacobian: J
   //
@@ -870,14 +865,14 @@
   problem_.SetManifold(x, new PolynomialManifold);
   problem_.SetParameterBlockConstant(x);
 
-  vector<int> subset;
+  std::vector<int> subset;
   subset.push_back(2);
   problem_.SetManifold(y, new SubsetManifold(3, subset));
   problem_.SetParameterBlockConstant(y);
 
-  local_column_bounds_[x] = make_pair(0, 1);
-  local_column_bounds_[y] = make_pair(1, 3);
-  local_column_bounds_[z] = make_pair(3, 4);
+  local_column_bounds_[x] = std::make_pair(0, 1);
+  local_column_bounds_[y] = std::make_pair(1, 3);
+  local_column_bounds_[z] = std::make_pair(3, 4);
 
   // Raw Jacobian: J
   //
@@ -987,7 +982,7 @@
   double* x = parameters_;
   double* y = x + 2;
   double* z = y + 3;
-  vector<const double*> parameter_blocks;
+  std::vector<const double*> parameter_blocks;
   parameter_blocks.push_back(x);
   parameter_blocks.push_back(y);
   parameter_blocks.push_back(z);
@@ -1016,7 +1011,7 @@
   double* x = parameters_;
   double* y = x + 2;
   double* z = y + 3;
-  vector<const double*> parameter_blocks;
+  std::vector<const double*> parameter_blocks;
   parameter_blocks.push_back(x);
   parameter_blocks.push_back(y);
   parameter_blocks.push_back(z);
@@ -1047,15 +1042,15 @@
 
   problem_.SetManifold(x, new PolynomialManifold);
 
-  vector<int> subset;
+  std::vector<int> subset;
   subset.push_back(2);
   problem_.SetManifold(y, new SubsetManifold(3, subset));
 
-  local_column_bounds_[x] = make_pair(0, 1);
-  local_column_bounds_[y] = make_pair(1, 3);
-  local_column_bounds_[z] = make_pair(3, 4);
+  local_column_bounds_[x] = std::make_pair(0, 1);
+  local_column_bounds_[y] = std::make_pair(1, 3);
+  local_column_bounds_[z] = std::make_pair(3, 4);
 
-  vector<const double*> parameter_blocks;
+  std::vector<const double*> parameter_blocks;
   parameter_blocks.push_back(x);
   parameter_blocks.push_back(y);
   parameter_blocks.push_back(z);
@@ -1084,7 +1079,7 @@
   Covariance covariance(options);
   double* x = parameters_;
   double* y = x + 2;
-  vector<const double*> parameter_blocks;
+  std::vector<const double*> parameter_blocks;
   parameter_blocks.push_back(x);
   parameter_blocks.push_back(x);
   parameter_blocks.push_back(y);
@@ -1092,7 +1087,7 @@
   EXPECT_DEATH_IF_SUPPORTED(covariance.Compute(parameter_blocks, &problem_),
                             "Covariance::Compute called with duplicate blocks "
                             "at indices \\(0, 1\\) and \\(2, 3\\)");
-  vector<pair<const double*, const double*>> covariance_blocks;
+  std::vector<std::pair<const double*, const double*>> covariance_blocks;
   covariance_blocks.emplace_back(x, x);
   covariance_blocks.emplace_back(x, x);
   covariance_blocks.emplace_back(y, y);
@@ -1148,9 +1143,9 @@
     all_covariance_blocks_.emplace_back(x, z);
     all_covariance_blocks_.emplace_back(y, z);
 
-    column_bounds_[x] = make_pair(0, 2);
-    column_bounds_[y] = make_pair(2, 5);
-    column_bounds_[z] = make_pair(5, 6);
+    column_bounds_[x] = std::make_pair(0, 2);
+    column_bounds_[y] = std::make_pair(2, 5);
+    column_bounds_[z] = std::make_pair(5, 6);
   }
 };
 
@@ -1217,7 +1212,7 @@
   Covariance::Options options;
   options.algorithm_type = DENSE_SVD;
   Covariance covariance(options);
-  vector<pair<const double*, const double*>> covariance_blocks;
+  std::vector<std::pair<const double*, const double*>> covariance_blocks;
   covariance_blocks.emplace_back(&x, &x);
   covariance_blocks.emplace_back(&x, &y);
   covariance_blocks.emplace_back(&y, &x);
@@ -1252,7 +1247,7 @@
   Covariance::Options options;
   options.algorithm_type = DENSE_SVD;
   Covariance covariance(options);
-  vector<pair<const double*, const double*>> covariance_blocks;
+  std::vector<std::pair<const double*, const double*>> covariance_blocks;
   covariance_blocks.emplace_back(&x, &x);
   covariance_blocks.emplace_back(&x, &y);
   covariance_blocks.emplace_back(&y, &x);
@@ -1348,7 +1343,7 @@
   int num_parameter_blocks_;
 
   Problem problem_;
-  vector<pair<const double*, const double*>> all_covariance_blocks_;
+  std::vector<std::pair<const double*, const double*>> all_covariance_blocks_;
 };
 
 #if !defined(CERES_NO_SUITESPARSE)
diff --git a/internal/ceres/dynamic_autodiff_cost_function_test.cc b/internal/ceres/dynamic_autodiff_cost_function_test.cc
index 6777d0c..d4800c2 100644
--- a/internal/ceres/dynamic_autodiff_cost_function_test.cc
+++ b/internal/ceres/dynamic_autodiff_cost_function_test.cc
@@ -39,8 +39,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
-
 // Takes 2 parameter blocks:
 //     parameters[0] is size 10.
 //     parameters[1] is size 5.
@@ -74,8 +72,8 @@
 };
 
 TEST(DynamicAutodiffCostFunctionTest, TestResiduals) {
-  vector<double> param_block_0(10, 0.0);
-  vector<double> param_block_1(5, 0.0);
+  std::vector<double> param_block_0(10, 0.0);
+  std::vector<double> param_block_1(5, 0.0);
   DynamicAutoDiffCostFunction<MyCostFunctor, 3> cost_function(
       new MyCostFunctor());
   cost_function.AddParameterBlock(param_block_0.size());
@@ -83,8 +81,8 @@
   cost_function.SetNumResiduals(21);
 
   // Test residual computation.
-  vector<double> residuals(21, -100000);
-  vector<double*> parameter_blocks(2);
+  std::vector<double> residuals(21, -100000);
+  std::vector<double*> parameter_blocks(2);
   parameter_blocks[0] = &param_block_0[0];
   parameter_blocks[1] = &param_block_1[0];
   EXPECT_TRUE(
@@ -98,11 +96,11 @@
 
 TEST(DynamicAutodiffCostFunctionTest, TestJacobian) {
   // Test the residual counting.
-  vector<double> param_block_0(10, 0.0);
+  std::vector<double> param_block_0(10, 0.0);
   for (int i = 0; i < 10; ++i) {
     param_block_0[i] = 2 * i;
   }
-  vector<double> param_block_1(5, 0.0);
+  std::vector<double> param_block_1(5, 0.0);
   DynamicAutoDiffCostFunction<MyCostFunctor, 3> cost_function(
       new MyCostFunctor());
   cost_function.AddParameterBlock(param_block_0.size());
@@ -110,18 +108,18 @@
   cost_function.SetNumResiduals(21);
 
   // Prepare the residuals.
-  vector<double> residuals(21, -100000);
+  std::vector<double> residuals(21, -100000);
 
   // Prepare the parameters.
-  vector<double*> parameter_blocks(2);
+  std::vector<double*> parameter_blocks(2);
   parameter_blocks[0] = &param_block_0[0];
   parameter_blocks[1] = &param_block_1[0];
 
   // Prepare the jacobian.
-  vector<vector<double>> jacobian_vect(2);
+  std::vector<std::vector<double>> jacobian_vect(2);
   jacobian_vect[0].resize(21 * 10, -100000);
   jacobian_vect[1].resize(21 * 5, -100000);
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(jacobian_vect[0].data());
   jacobian.push_back(jacobian_vect[1].data());
 
@@ -164,11 +162,11 @@
 
 TEST(DynamicAutodiffCostFunctionTest, JacobianWithFirstParameterBlockConstant) {
   // Test the residual counting.
-  vector<double> param_block_0(10, 0.0);
+  std::vector<double> param_block_0(10, 0.0);
   for (int i = 0; i < 10; ++i) {
     param_block_0[i] = 2 * i;
   }
-  vector<double> param_block_1(5, 0.0);
+  std::vector<double> param_block_1(5, 0.0);
   DynamicAutoDiffCostFunction<MyCostFunctor, 3> cost_function(
       new MyCostFunctor());
   cost_function.AddParameterBlock(param_block_0.size());
@@ -176,18 +174,18 @@
   cost_function.SetNumResiduals(21);
 
   // Prepare the residuals.
-  vector<double> residuals(21, -100000);
+  std::vector<double> residuals(21, -100000);
 
   // Prepare the parameters.
-  vector<double*> parameter_blocks(2);
+  std::vector<double*> parameter_blocks(2);
   parameter_blocks[0] = &param_block_0[0];
   parameter_blocks[1] = &param_block_1[0];
 
   // Prepare the jacobian.
-  vector<vector<double>> jacobian_vect(2);
+  std::vector<std::vector<double>> jacobian_vect(2);
   jacobian_vect[0].resize(21 * 10, -100000);
   jacobian_vect[1].resize(21 * 5, -100000);
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(nullptr);
   jacobian.push_back(jacobian_vect[1].data());
 
@@ -214,11 +212,11 @@
 TEST(DynamicAutodiffCostFunctionTest,
      JacobianWithSecondParameterBlockConstant) {  // NOLINT
   // Test the residual counting.
-  vector<double> param_block_0(10, 0.0);
+  std::vector<double> param_block_0(10, 0.0);
   for (int i = 0; i < 10; ++i) {
     param_block_0[i] = 2 * i;
   }
-  vector<double> param_block_1(5, 0.0);
+  std::vector<double> param_block_1(5, 0.0);
   DynamicAutoDiffCostFunction<MyCostFunctor, 3> cost_function(
       new MyCostFunctor());
   cost_function.AddParameterBlock(param_block_0.size());
@@ -226,18 +224,18 @@
   cost_function.SetNumResiduals(21);
 
   // Prepare the residuals.
-  vector<double> residuals(21, -100000);
+  std::vector<double> residuals(21, -100000);
 
   // Prepare the parameters.
-  vector<double*> parameter_blocks(2);
+  std::vector<double*> parameter_blocks(2);
   parameter_blocks[0] = &param_block_0[0];
   parameter_blocks[1] = &param_block_1[0];
 
   // Prepare the jacobian.
-  vector<vector<double>> jacobian_vect(2);
+  std::vector<std::vector<double>> jacobian_vect(2);
   jacobian_vect[0].resize(21 * 10, -100000);
   jacobian_vect[1].resize(21 * 5, -100000);
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(jacobian_vect[0].data());
   jacobian.push_back(nullptr);
 
@@ -408,25 +406,25 @@
   }
 
  protected:
-  vector<double> x_;
-  vector<double> y_;
-  vector<double> z_;
+  std::vector<double> x_;
+  std::vector<double> y_;
+  std::vector<double> z_;
 
-  vector<double*> parameter_blocks_;
+  std::vector<double*> parameter_blocks_;
 
   std::unique_ptr<CostFunction> cost_function_;
 
-  vector<vector<double>> jacobian_vect_;
+  std::vector<std::vector<double>> jacobian_vect_;
 
-  vector<double> expected_residuals_;
+  std::vector<double> expected_residuals_;
 
-  vector<double> expected_jacobian_x_;
-  vector<double> expected_jacobian_y_;
-  vector<double> expected_jacobian_z_;
+  std::vector<double> expected_jacobian_x_;
+  std::vector<double> expected_jacobian_y_;
+  std::vector<double> expected_jacobian_z_;
 };
 
 TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterResiduals) {
-  vector<double> residuals(7, -100000);
+  std::vector<double> residuals(7, -100000);
   EXPECT_TRUE(cost_function_->Evaluate(
       parameter_blocks_.data(), residuals.data(), nullptr));
   for (int i = 0; i < 7; ++i) {
@@ -435,9 +433,9 @@
 }
 
 TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterJacobian) {
-  vector<double> residuals(7, -100000);
+  std::vector<double> residuals(7, -100000);
 
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(jacobian_vect_[0].data());
   jacobian.push_back(jacobian_vect_[1].data());
   jacobian.push_back(jacobian_vect_[2].data());
@@ -464,9 +462,9 @@
 
 TEST_F(ThreeParameterCostFunctorTest,
        ThreeParameterJacobianWithFirstAndLastParameterBlockConstant) {
-  vector<double> residuals(7, -100000);
+  std::vector<double> residuals(7, -100000);
 
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(nullptr);
   jacobian.push_back(jacobian_vect_[1].data());
   jacobian.push_back(nullptr);
@@ -485,9 +483,9 @@
 
 TEST_F(ThreeParameterCostFunctorTest,
        ThreeParameterJacobianWithSecondParameterBlockConstant) {
-  vector<double> residuals(7, -100000);
+  std::vector<double> residuals(7, -100000);
 
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(jacobian_vect_[0].data());
   jacobian.push_back(nullptr);
   jacobian.push_back(jacobian_vect_[2].data());
@@ -654,18 +652,18 @@
   double z1_;
   double z2_;
 
-  vector<double*> parameter_blocks_;
+  std::vector<double*> parameter_blocks_;
 
   std::unique_ptr<CostFunction> cost_function_;
 
-  vector<vector<double>> jacobian_vect_;
+  std::vector<std::vector<double>> jacobian_vect_;
 
-  vector<double> expected_residuals_;
-  vector<vector<double>> expected_jacobians_;
+  std::vector<double> expected_residuals_;
+  std::vector<std::vector<double>> expected_jacobians_;
 };
 
 TEST_F(SixParameterCostFunctorTest, TestSixParameterResiduals) {
-  vector<double> residuals(7, -100000);
+  std::vector<double> residuals(7, -100000);
   EXPECT_TRUE(cost_function_->Evaluate(
       parameter_blocks_.data(), residuals.data(), nullptr));
   for (int i = 0; i < 7; ++i) {
@@ -674,9 +672,9 @@
 }
 
 TEST_F(SixParameterCostFunctorTest, TestSixParameterJacobian) {
-  vector<double> residuals(7, -100000);
+  std::vector<double> residuals(7, -100000);
 
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(jacobian_vect_[0].data());
   jacobian.push_back(jacobian_vect_[1].data());
   jacobian.push_back(jacobian_vect_[2].data());
@@ -699,9 +697,9 @@
 }
 
 TEST_F(SixParameterCostFunctorTest, TestSixParameterJacobianVVCVVC) {
-  vector<double> residuals(7, -100000);
+  std::vector<double> residuals(7, -100000);
 
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(jacobian_vect_[0].data());
   jacobian.push_back(jacobian_vect_[1].data());
   jacobian.push_back(nullptr);
@@ -729,9 +727,9 @@
 }
 
 TEST_F(SixParameterCostFunctorTest, TestSixParameterJacobianVCCVCV) {
-  vector<double> residuals(7, -100000);
+  std::vector<double> residuals(7, -100000);
 
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(jacobian_vect_[0].data());
   jacobian.push_back(nullptr);
   jacobian.push_back(nullptr);
diff --git a/internal/ceres/dynamic_compressed_row_jacobian_writer.cc b/internal/ceres/dynamic_compressed_row_jacobian_writer.cc
index a97c333..78d1875 100644
--- a/internal/ceres/dynamic_compressed_row_jacobian_writer.cc
+++ b/internal/ceres/dynamic_compressed_row_jacobian_writer.cc
@@ -41,9 +41,6 @@
 
 namespace ceres::internal {
 
-using std::pair;
-using std::vector;
-
 std::unique_ptr<ScratchEvaluatePreparer[]>
 DynamicCompressedRowJacobianWriter::CreateEvaluatePreparers(int num_threads) {
   return ScratchEvaluatePreparer::Create(*program_, num_threads);
@@ -68,7 +65,7 @@
       program_->residual_blocks()[residual_id];
   const int num_residuals = residual_block->NumResiduals();
 
-  vector<pair<int, int>> evaluated_jacobian_blocks;
+  std::vector<std::pair<int, int>> evaluated_jacobian_blocks;
   CompressedRowJacobianWriter::GetOrderedParameterBlocks(
       program_, residual_id, &evaluated_jacobian_blocks);
 
diff --git a/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc b/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
index 269858f..c32233c 100644
--- a/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
+++ b/internal/ceres/dynamic_compressed_row_sparse_matrix_test.cc
@@ -42,9 +42,6 @@
 namespace ceres {
 namespace internal {
 
-using std::copy;
-using std::vector;
-
 class DynamicCompressedRowSparseMatrixTest : public ::testing::Test {
  protected:
   void SetUp() final {
@@ -82,8 +79,8 @@
   }
 
   void InitialiseSparseMatrixReferences() {
-    vector<int> rows, cols;
-    vector<double> values;
+    std::vector<int> rows, cols;
+    std::vector<double> values;
     for (int i = 0; i < (num_rows * num_cols); ++i) {
       const int r = i / num_cols, c = i % num_cols;
       if (r != c) {
@@ -96,9 +93,9 @@
 
     tsm = std::make_unique<TripletSparseMatrix>(
         num_rows, num_cols, expected_num_nonzeros);
-    copy(rows.begin(), rows.end(), tsm->mutable_rows());
-    copy(cols.begin(), cols.end(), tsm->mutable_cols());
-    copy(values.begin(), values.end(), tsm->mutable_values());
+    std::copy(rows.begin(), rows.end(), tsm->mutable_rows());
+    std::copy(cols.begin(), cols.end(), tsm->mutable_cols());
+    std::copy(values.begin(), values.end(), tsm->mutable_values());
     tsm->set_num_nonzeros(values.size());
 
     Matrix dense_from_tsm;
diff --git a/internal/ceres/dynamic_numeric_diff_cost_function_test.cc b/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
index f2a37e3..0dae837 100644
--- a/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
+++ b/internal/ceres/dynamic_numeric_diff_cost_function_test.cc
@@ -38,8 +38,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
-
 const double kTolerance = 1e-6;
 
 // Takes 2 parameter blocks:
@@ -74,8 +72,8 @@
 };
 
 TEST(DynamicNumericdiffCostFunctionTest, TestResiduals) {
-  vector<double> param_block_0(10, 0.0);
-  vector<double> param_block_1(5, 0.0);
+  std::vector<double> param_block_0(10, 0.0);
+  std::vector<double> param_block_1(5, 0.0);
   DynamicNumericDiffCostFunction<MyCostFunctor> cost_function(
       new MyCostFunctor());
   cost_function.AddParameterBlock(param_block_0.size());
@@ -83,8 +81,8 @@
   cost_function.SetNumResiduals(21);
 
   // Test residual computation.
-  vector<double> residuals(21, -100000);
-  vector<double*> parameter_blocks(2);
+  std::vector<double> residuals(21, -100000);
+  std::vector<double*> parameter_blocks(2);
   parameter_blocks[0] = &param_block_0[0];
   parameter_blocks[1] = &param_block_1[0];
   EXPECT_TRUE(
@@ -98,11 +96,11 @@
 
 TEST(DynamicNumericdiffCostFunctionTest, TestJacobian) {
   // Test the residual counting.
-  vector<double> param_block_0(10, 0.0);
+  std::vector<double> param_block_0(10, 0.0);
   for (int i = 0; i < 10; ++i) {
     param_block_0[i] = 2 * i;
   }
-  vector<double> param_block_1(5, 0.0);
+  std::vector<double> param_block_1(5, 0.0);
   DynamicNumericDiffCostFunction<MyCostFunctor> cost_function(
       new MyCostFunctor());
   cost_function.AddParameterBlock(param_block_0.size());
@@ -110,18 +108,18 @@
   cost_function.SetNumResiduals(21);
 
   // Prepare the residuals.
-  vector<double> residuals(21, -100000);
+  std::vector<double> residuals(21, -100000);
 
   // Prepare the parameters.
-  vector<double*> parameter_blocks(2);
+  std::vector<double*> parameter_blocks(2);
   parameter_blocks[0] = &param_block_0[0];
   parameter_blocks[1] = &param_block_1[0];
 
   // Prepare the jacobian.
-  vector<vector<double>> jacobian_vect(2);
+  std::vector<std::vector<double>> jacobian_vect(2);
   jacobian_vect[0].resize(21 * 10, -100000);
   jacobian_vect[1].resize(21 * 5, -100000);
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(jacobian_vect[0].data());
   jacobian.push_back(jacobian_vect[1].data());
 
@@ -165,11 +163,11 @@
 TEST(DynamicNumericdiffCostFunctionTest,
      JacobianWithFirstParameterBlockConstant) {  // NOLINT
   // Test the residual counting.
-  vector<double> param_block_0(10, 0.0);
+  std::vector<double> param_block_0(10, 0.0);
   for (int i = 0; i < 10; ++i) {
     param_block_0[i] = 2 * i;
   }
-  vector<double> param_block_1(5, 0.0);
+  std::vector<double> param_block_1(5, 0.0);
   DynamicNumericDiffCostFunction<MyCostFunctor> cost_function(
       new MyCostFunctor());
   cost_function.AddParameterBlock(param_block_0.size());
@@ -177,18 +175,18 @@
   cost_function.SetNumResiduals(21);
 
   // Prepare the residuals.
-  vector<double> residuals(21, -100000);
+  std::vector<double> residuals(21, -100000);
 
   // Prepare the parameters.
-  vector<double*> parameter_blocks(2);
+  std::vector<double*> parameter_blocks(2);
   parameter_blocks[0] = &param_block_0[0];
   parameter_blocks[1] = &param_block_1[0];
 
   // Prepare the jacobian.
-  vector<vector<double>> jacobian_vect(2);
+  std::vector<std::vector<double>> jacobian_vect(2);
   jacobian_vect[0].resize(21 * 10, -100000);
   jacobian_vect[1].resize(21 * 5, -100000);
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(nullptr);
   jacobian.push_back(jacobian_vect[1].data());
 
@@ -215,11 +213,11 @@
 TEST(DynamicNumericdiffCostFunctionTest,
      JacobianWithSecondParameterBlockConstant) {  // NOLINT
   // Test the residual counting.
-  vector<double> param_block_0(10, 0.0);
+  std::vector<double> param_block_0(10, 0.0);
   for (int i = 0; i < 10; ++i) {
     param_block_0[i] = 2 * i;
   }
-  vector<double> param_block_1(5, 0.0);
+  std::vector<double> param_block_1(5, 0.0);
   DynamicNumericDiffCostFunction<MyCostFunctor> cost_function(
       new MyCostFunctor());
   cost_function.AddParameterBlock(param_block_0.size());
@@ -227,18 +225,18 @@
   cost_function.SetNumResiduals(21);
 
   // Prepare the residuals.
-  vector<double> residuals(21, -100000);
+  std::vector<double> residuals(21, -100000);
 
   // Prepare the parameters.
-  vector<double*> parameter_blocks(2);
+  std::vector<double*> parameter_blocks(2);
   parameter_blocks[0] = &param_block_0[0];
   parameter_blocks[1] = &param_block_1[0];
 
   // Prepare the jacobian.
-  vector<vector<double>> jacobian_vect(2);
+  std::vector<std::vector<double>> jacobian_vect(2);
   jacobian_vect[0].resize(21 * 10, -100000);
   jacobian_vect[1].resize(21 * 5, -100000);
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(jacobian_vect[0].data());
   jacobian.push_back(nullptr);
 
@@ -409,25 +407,25 @@
   }
 
  protected:
-  vector<double> x_;
-  vector<double> y_;
-  vector<double> z_;
+  std::vector<double> x_;
+  std::vector<double> y_;
+  std::vector<double> z_;
 
-  vector<double*> parameter_blocks_;
+  std::vector<double*> parameter_blocks_;
 
   std::unique_ptr<CostFunction> cost_function_;
 
-  vector<vector<double>> jacobian_vect_;
+  std::vector<std::vector<double>> jacobian_vect_;
 
-  vector<double> expected_residuals_;
+  std::vector<double> expected_residuals_;
 
-  vector<double> expected_jacobian_x_;
-  vector<double> expected_jacobian_y_;
-  vector<double> expected_jacobian_z_;
+  std::vector<double> expected_jacobian_x_;
+  std::vector<double> expected_jacobian_y_;
+  std::vector<double> expected_jacobian_z_;
 };
 
 TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterResiduals) {
-  vector<double> residuals(7, -100000);
+  std::vector<double> residuals(7, -100000);
   EXPECT_TRUE(cost_function_->Evaluate(
       parameter_blocks_.data(), residuals.data(), nullptr));
   for (int i = 0; i < 7; ++i) {
@@ -436,9 +434,9 @@
 }
 
 TEST_F(ThreeParameterCostFunctorTest, TestThreeParameterJacobian) {
-  vector<double> residuals(7, -100000);
+  std::vector<double> residuals(7, -100000);
 
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(jacobian_vect_[0].data());
   jacobian.push_back(jacobian_vect_[1].data());
   jacobian.push_back(jacobian_vect_[2].data());
@@ -465,9 +463,9 @@
 
 TEST_F(ThreeParameterCostFunctorTest,
        ThreeParameterJacobianWithFirstAndLastParameterBlockConstant) {
-  vector<double> residuals(7, -100000);
+  std::vector<double> residuals(7, -100000);
 
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(nullptr);
   jacobian.push_back(jacobian_vect_[1].data());
   jacobian.push_back(nullptr);
@@ -486,9 +484,9 @@
 
 TEST_F(ThreeParameterCostFunctorTest,
        ThreeParameterJacobianWithSecondParameterBlockConstant) {
-  vector<double> residuals(7, -100000);
+  std::vector<double> residuals(7, -100000);
 
-  vector<double*> jacobian;
+  std::vector<double*> jacobian;
   jacobian.push_back(jacobian_vect_[0].data());
   jacobian.push_back(nullptr);
   jacobian.push_back(jacobian_vect_[2].data());
diff --git a/internal/ceres/evaluator_test.cc b/internal/ceres/evaluator_test.cc
index 24da250..d9a1b21 100644
--- a/internal/ceres/evaluator_test.cc
+++ b/internal/ceres/evaluator_test.cc
@@ -52,9 +52,6 @@
 namespace ceres {
 namespace internal {
 
-using std::string;
-using std::vector;
-
 // TODO(keir): Consider pushing this into a common test utils file.
 template <int kFactor, int kNumResiduals, int... Ns>
 class ParameterIgnoringCostFunction
@@ -122,7 +119,7 @@
     program->SetParameterOffsetsAndIndex();
 
     if (VLOG_IS_ON(1)) {
-      string report;
+      std::string report;
       StringAppendF(&report,
                     "Creating evaluator with type: %d",
                     GetParam().linear_solver_type);
@@ -140,7 +137,7 @@
     options.num_eliminate_blocks = GetParam().num_eliminate_blocks;
     options.dynamic_sparsity = GetParam().dynamic_sparsity;
     options.context = problem.context();
-    string error;
+    std::string error;
     return Evaluator::Create(options, program, &error);
   }
 
@@ -171,7 +168,7 @@
     ASSERT_EQ(expected_num_rows, jacobian->num_rows());
     ASSERT_EQ(expected_num_cols, jacobian->num_cols());
 
-    vector<double> state(evaluator->NumParameters());
+    std::vector<double> state(evaluator->NumParameters());
 
     // clang-format off
     ASSERT_TRUE(evaluator->Evaluate(
@@ -399,12 +396,12 @@
   problem.AddParameterBlock(x, 2);
 
   // Fix y's first dimension.
-  vector<int> y_fixed;
+  std::vector<int> y_fixed;
   y_fixed.push_back(0);
   problem.AddParameterBlock(y, 3, new SubsetManifold(3, y_fixed));
 
   // Fix z's second dimension.
-  vector<int> z_fixed;
+  std::vector<int> z_fixed;
   z_fixed.push_back(1);
   problem.AddParameterBlock(z, 4, new SubsetManifold(4, z_fixed));
 
@@ -486,7 +483,7 @@
   // Normally, the preprocessing of the program that happens in solver_impl
   // takes care of this, but we don't want to invoke the solver here.
   Program reduced_program;
-  vector<ParameterBlock*>* parameter_blocks =
+  std::vector<ParameterBlock*>* parameter_blocks =
       problem.mutable_program()->mutable_parameter_blocks();
 
   // "z" is the last parameter; save it for later and pop it off temporarily.
@@ -620,7 +617,7 @@
   options.linear_solver_type = DENSE_QR;
   options.num_eliminate_blocks = 0;
   options.context = problem.context();
-  string error;
+  std::string error;
   std::unique_ptr<Evaluator> evaluator(
       Evaluator::Create(options, program, &error));
   std::unique_ptr<SparseMatrix> jacobian(evaluator->CreateJacobian());
diff --git a/internal/ceres/file.cc b/internal/ceres/file.cc
index cd91843..601964f 100644
--- a/internal/ceres/file.cc
+++ b/internal/ceres/file.cc
@@ -38,9 +38,7 @@
 
 namespace ceres::internal {
 
-using std::string;
-
-void WriteStringToFileOrDie(const string& data, const string& filename) {
+void WriteStringToFileOrDie(const std::string& data, const std::string& filename) {
   FILE* file_descriptor = fopen(filename.c_str(), "wb");
   if (!file_descriptor) {
     LOG(FATAL) << "Couldn't write to file: " << filename;
@@ -49,7 +47,7 @@
   fclose(file_descriptor);
 }
 
-void ReadFileToStringOrDie(const string& filename, string* data) {
+void ReadFileToStringOrDie(const std::string& filename, std::string* data) {
   FILE* file_descriptor = fopen(filename.c_str(), "r");
 
   if (!file_descriptor) {
@@ -73,7 +71,7 @@
   fclose(file_descriptor);
 }
 
-string JoinPath(const string& dirname, const string& basename) {
+std::string JoinPath(const std::string& dirname, const std::string& basename) {
 #ifdef _WIN32
   static const char separator = '\\';
 #else
@@ -85,7 +83,7 @@
   } else if (dirname[dirname.size() - 1] == separator) {
     return dirname + basename;
   } else {
-    return dirname + string(&separator, 1) + basename;
+    return dirname + std::string(&separator, 1) + basename;
   }
 }
 
diff --git a/internal/ceres/gradient_checker.cc b/internal/ceres/gradient_checker.cc
index 68bcf86..dfd5c6a 100644
--- a/internal/ceres/gradient_checker.cc
+++ b/internal/ceres/gradient_checker.cc
@@ -48,8 +48,6 @@
 using internal::IsClose;
 using internal::StringAppendF;
 using internal::StringPrintf;
-using std::string;
-using std::vector;
 
 namespace {
 // Evaluate the cost function and transform the returned Jacobians to
@@ -64,12 +62,12 @@
   CHECK(jacobians != nullptr);
   CHECK(local_jacobians != nullptr);
 
-  const vector<int32_t>& block_sizes = function->parameter_block_sizes();
+  const std::vector<int32_t>& block_sizes = function->parameter_block_sizes();
   const int num_parameter_blocks = block_sizes.size();
 
   // Allocate Jacobian matrices in tangent space.
   local_jacobians->resize(num_parameter_blocks);
-  vector<double*> local_jacobian_data(num_parameter_blocks);
+  std::vector<double*> local_jacobian_data(num_parameter_blocks);
   for (int i = 0; i < num_parameter_blocks; ++i) {
     int block_size = block_sizes.at(i);
     if (manifolds.at(i) != nullptr) {
@@ -82,7 +80,7 @@
 
   // Allocate Jacobian matrices in ambient space.
   jacobians->resize(num_parameter_blocks);
-  vector<double*> jacobian_data(num_parameter_blocks);
+  std::vector<double*> jacobian_data(num_parameter_blocks);
   for (int i = 0; i < num_parameter_blocks; ++i) {
     jacobians->at(i).resize(function->num_residuals(), block_sizes.at(i));
     jacobians->at(i).setZero();
@@ -116,7 +114,7 @@
 }  // namespace
 
 GradientChecker::GradientChecker(const CostFunction* function,
-                                 const vector<const Manifold*>* manifolds,
+                                 const std::vector<const Manifold*>* manifolds,
                                  const NumericDiffOptions& options)
     : function_(function) {
   CHECK(function != nullptr);
@@ -129,7 +127,7 @@
   auto finite_diff_cost_function =
       std::make_unique<DynamicNumericDiffCostFunction<CostFunction, RIDDERS>>(
           function, DO_NOT_TAKE_OWNERSHIP, options);
-  const vector<int32_t>& parameter_block_sizes =
+  const std::vector<int32_t>& parameter_block_sizes =
       function->parameter_block_sizes();
   const int num_parameter_blocks = parameter_block_sizes.size();
   for (int i = 0; i < num_parameter_blocks; ++i) {
@@ -164,8 +162,8 @@
   results->return_value = true;
 
   // Evaluate the derivative using the user supplied code.
-  vector<Matrix>& jacobians = results->jacobians;
-  vector<Matrix>& local_jacobians = results->local_jacobians;
+  std::vector<Matrix>& jacobians = results->jacobians;
+  std::vector<Matrix>& local_jacobians = results->local_jacobians;
   if (!EvaluateCostFunction(function_,
                             parameters,
                             manifolds_,
@@ -177,8 +175,8 @@
   }
 
   // Evaluate the derivative using numeric derivatives.
-  vector<Matrix>& numeric_jacobians = results->numeric_jacobians;
-  vector<Matrix>& local_numeric_jacobians = results->local_numeric_jacobians;
+  std::vector<Matrix>& numeric_jacobians = results->numeric_jacobians;
+  std::vector<Matrix>& local_numeric_jacobians = results->local_numeric_jacobians;
   Vector finite_diff_residuals;
   if (!EvaluateCostFunction(finite_diff_cost_function_.get(),
                             parameters,
@@ -218,7 +216,7 @@
 
   // Accumulate the error message for all the jacobians, since it won't get
   // output if there are no bad jacobian components.
-  string error_log;
+  std::string error_log;
   for (int k = 0; k < function_->parameter_block_sizes().size(); k++) {
     StringAppendF(&error_log,
                   "========== "
@@ -272,7 +270,7 @@
 
   // Since there were some bad errors, dump comprehensive debug info.
   if (num_bad_jacobian_components) {
-    string header = StringPrintf(
+    std::string header = StringPrintf(
         "\nDetected %d bad Jacobian component(s). "
         "Worst relative error was %g.\n",
         num_bad_jacobian_components,
diff --git a/internal/ceres/gradient_checker_test.cc b/internal/ceres/gradient_checker_test.cc
index 1e6fe9a..3508455 100644
--- a/internal/ceres/gradient_checker_test.cc
+++ b/internal/ceres/gradient_checker_test.cc
@@ -46,7 +46,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
 const double kTolerance = 1e-12;
 
 // We pick a (non-quadratic) function whose derivative are easy:
@@ -115,7 +114,7 @@
  private:
   int arity_;
   bool return_value_;
-  vector<vector<double>> a_;  // our vectors.
+  std::vector<std::vector<double>> a_;  // our vectors.
 };
 
 class BadTestTerm : public CostFunction {
@@ -170,7 +169,7 @@
 
  private:
   int arity_;
-  vector<vector<double>> a_;  // our vectors.
+  std::vector<std::vector<double>> a_;  // our vectors.
 };
 
 static void CheckDimensions(const GradientChecker::ProbeResults& results,
diff --git a/internal/ceres/gradient_checking_cost_function.cc b/internal/ceres/gradient_checking_cost_function.cc
index 04440c2..013a98a 100644
--- a/internal/ceres/gradient_checking_cost_function.cc
+++ b/internal/ceres/gradient_checking_cost_function.cc
@@ -54,11 +54,6 @@
 
 namespace ceres::internal {
 
-using std::abs;
-using std::max;
-using std::string;
-using std::vector;
-
 namespace {
 
 class GradientCheckingCostFunction final : public CostFunction {
@@ -67,7 +62,7 @@
                                const std::vector<const Manifold*>* manifolds,
                                const NumericDiffOptions& options,
                                double relative_precision,
-                               string extra_info,
+                               std::string extra_info,
                                GradientCheckingIterationCallback* callback)
       : function_(function),
         gradient_checker_(function, manifolds, options),
@@ -75,7 +70,7 @@
         extra_info_(std::move(extra_info)),
         callback_(callback) {
     CHECK(callback_ != nullptr);
-    const vector<int32_t>& parameter_block_sizes =
+    const std::vector<int32_t>& parameter_block_sizes =
         function->parameter_block_sizes();
     *mutable_parameter_block_sizes() = parameter_block_sizes;
     set_num_residuals(function->num_residuals());
@@ -104,7 +99,7 @@
     MatrixRef(residuals, num_residuals, 1) = results.residuals;
 
     // Copy the original jacobian blocks into the jacobians array.
-    const vector<int32_t>& block_sizes = function_->parameter_block_sizes();
+    const std::vector<int32_t>& block_sizes = function_->parameter_block_sizes();
     for (int k = 0; k < block_sizes.size(); k++) {
       if (jacobians[k] != nullptr) {
         MatrixRef(jacobians[k],
@@ -126,7 +121,7 @@
   const CostFunction* function_;
   GradientChecker gradient_checker_;
   double relative_precision_;
-  string extra_info_;
+  std::string extra_info_;
   GradientCheckingIterationCallback* callback_;
 };
 
@@ -197,7 +192,7 @@
 
   // For every ParameterBlock in problem_impl, create a new parameter block with
   // the same manifold and constancy.
-  const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
+  const std::vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
   for (auto* parameter_block : parameter_blocks) {
     gradient_checking_problem_impl->AddParameterBlock(
         parameter_block->mutable_user_state(),
@@ -224,17 +219,17 @@
   // For every ResidualBlock in problem_impl, create a new
   // ResidualBlock by wrapping its CostFunction inside a
   // GradientCheckingCostFunction.
-  const vector<ResidualBlock*>& residual_blocks = program->residual_blocks();
+  const std::vector<ResidualBlock*>& residual_blocks = program->residual_blocks();
   for (int i = 0; i < residual_blocks.size(); ++i) {
     ResidualBlock* residual_block = residual_blocks[i];
 
     // Build a human readable string which identifies the
     // ResidualBlock. This is used by the GradientCheckingCostFunction
     // when logging debugging information.
-    string extra_info =
+    std::string extra_info =
         StringPrintf("Residual block id %d; depends on parameters [", i);
-    vector<double*> parameter_blocks;
-    vector<const Manifold*> manifolds;
+    std::vector<double*> parameter_blocks;
+    std::vector<const Manifold*> manifolds;
     parameter_blocks.reserve(residual_block->NumParameterBlocks());
     manifolds.reserve(residual_block->NumParameterBlocks());
     for (int j = 0; j < residual_block->NumParameterBlocks(); ++j) {
diff --git a/internal/ceres/gradient_checking_cost_function_test.cc b/internal/ceres/gradient_checking_cost_function_test.cc
index 87c3278..027aa67 100644
--- a/internal/ceres/gradient_checking_cost_function_test.cc
+++ b/internal/ceres/gradient_checking_cost_function_test.cc
@@ -51,7 +51,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
 using testing::_;
 using testing::AllOf;
 using testing::AnyNumber;
@@ -128,7 +127,7 @@
 
  private:
   int arity_;
-  vector<vector<double>> a_;
+  std::vector<std::vector<double>> a_;
 };
 
 TEST(GradientCheckingCostFunction, ResidualsAndJacobiansArePreservedTest) {
@@ -137,7 +136,7 @@
   int const dim[arity] = {2, 3, 4};
 
   // Make a random set of blocks.
-  vector<double*> parameters(arity);
+  std::vector<double*> parameters(arity);
   std::mt19937 prng;
   std::uniform_real_distribution<double> distribution(-1.0, 1.0);
   auto randu = [&prng, &distribution] { return distribution(prng); };
@@ -150,8 +149,8 @@
 
   double original_residual;
   double residual;
-  vector<double*> original_jacobians(arity);
-  vector<double*> jacobians(arity);
+  std::vector<double*> original_jacobians(arity);
+  std::vector<double*> jacobians(arity);
 
   for (int j = 0; j < arity; ++j) {
     // Since residual is one dimensional the jacobians have the same
@@ -195,7 +194,7 @@
   int const dim[arity] = {2, 3, 4};
 
   // Make a random set of blocks.
-  vector<double*> parameters(arity);
+  std::vector<double*> parameters(arity);
   std::mt19937 prng;
   std::uniform_real_distribution<double> distribution(-1.0, 1.0);
   auto randu = [&prng, &distribution] { return distribution(prng); };
@@ -207,7 +206,7 @@
   }
 
   double residual;
-  vector<double*> jacobians(arity);
+  std::vector<double*> jacobians(arity);
   for (int j = 0; j < arity; ++j) {
     // Since residual is one dimensional the jacobians have the same size as the
     // parameter blocks.
diff --git a/internal/ceres/gradient_problem_solver.cc b/internal/ceres/gradient_problem_solver.cc
index 114b0ee..3438409 100644
--- a/internal/ceres/gradient_problem_solver.cc
+++ b/internal/ceres/gradient_problem_solver.cc
@@ -49,7 +49,6 @@
 namespace ceres {
 using internal::StringAppendF;
 using internal::StringPrintf;
-using std::string;
 
 namespace {
 
@@ -181,7 +180,7 @@
     SetSummaryFinalCost(summary);
   }
 
-  const std::map<string, CallStatistics>& evaluator_statistics =
+  const std::map<std::string, CallStatistics>& evaluator_statistics =
       minimizer_options.evaluator->Statistics();
   {
     const CallStatistics& call_stats = FindWithDefault(
@@ -204,7 +203,7 @@
   return internal::IsSolutionUsable(*this);
 }
 
-string GradientProblemSolver::Summary::BriefReport() const {
+std::string GradientProblemSolver::Summary::BriefReport() const {
   return StringPrintf(
       "Ceres GradientProblemSolver Report: "
       "Iterations: %d, "
@@ -217,12 +216,12 @@
       TerminationTypeToString(termination_type));
 }
 
-string GradientProblemSolver::Summary::FullReport() const {
+std::string GradientProblemSolver::Summary::FullReport() const {
   using internal::VersionString;
 
   // NOTE operator+ is not usable for concatenating a string and a string_view.
-  string report =
-      string{"\nSolver Summary (v "}.append(VersionString()) + ")\n\n";
+  std::string report =
+      std::string{"\nSolver Summary (v "}.append(VersionString()) + ")\n\n";
 
   StringAppendF(&report, "Parameters          % 25d\n", num_parameters);
   if (num_tangent_parameters != num_parameters) {
@@ -230,7 +229,7 @@
         &report, "Tangent parameters   % 25d\n", num_tangent_parameters);
   }
 
-  string line_search_direction_string;
+  std::string line_search_direction_string;
   if (line_search_direction_type == LBFGS) {
     line_search_direction_string = StringPrintf("LBFGS (%d)", max_lbfgs_rank);
   } else if (line_search_direction_type == NONLINEAR_CONJUGATE_GRADIENT) {
@@ -245,7 +244,7 @@
                 "Line search direction     %19s\n",
                 line_search_direction_string.c_str());
 
-  const string line_search_type_string = StringPrintf(
+  const std::string line_search_type_string = StringPrintf(
       "%s %s",
       LineSearchInterpolationTypeToString(line_search_interpolation_type),
       LineSearchTypeToString(line_search_type));
diff --git a/internal/ceres/graph_algorithms_test.cc b/internal/ceres/graph_algorithms_test.cc
index c03cda4..ac56497 100644
--- a/internal/ceres/graph_algorithms_test.cc
+++ b/internal/ceres/graph_algorithms_test.cc
@@ -40,8 +40,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
-
 TEST(IndependentSetOrdering, Chain) {
   Graph<int> graph;
   graph.AddVertex(0);
@@ -57,7 +55,7 @@
 
   // 0-1-2-3-4
   // 0, 2, 4 should be in the independent set.
-  vector<int> ordering;
+  std::vector<int> ordering;
   int independent_set_size = IndependentSetOrdering(graph, &ordering);
 
   sort(ordering.begin(), ordering.begin() + 3);
@@ -91,7 +89,7 @@
   //      |
   //      3
   // 1, 2, 3, 4 should be in the independent set.
-  vector<int> ordering;
+  std::vector<int> ordering;
   int independent_set_size = IndependentSetOrdering(graph, &ordering);
   EXPECT_EQ(independent_set_size, 4);
   EXPECT_EQ(ordering.size(), 5);
@@ -219,7 +217,7 @@
   // guarantees that it will always be the first vertex in the
   // ordering vector.
   {
-    vector<int> ordering;
+    std::vector<int> ordering;
     ordering.push_back(0);
     ordering.push_back(1);
     ordering.push_back(2);
@@ -231,7 +229,7 @@
   }
 
   {
-    vector<int> ordering;
+    std::vector<int> ordering;
     ordering.push_back(1);
     ordering.push_back(0);
     ordering.push_back(2);
diff --git a/internal/ceres/line_search.cc b/internal/ceres/line_search.cc
index 68d6bbe..2b6fe4d 100644
--- a/internal/ceres/line_search.cc
+++ b/internal/ceres/line_search.cc
@@ -47,20 +47,15 @@
 
 namespace ceres::internal {
 
-using std::map;
-using std::ostream;
-using std::string;
-using std::vector;
-
 namespace {
 // Precision used for floating point values in error message output.
 const int kErrorMessageNumericPrecision = 8;
 }  // namespace
 
-ostream& operator<<(ostream& os, const FunctionSample& sample);
+std::ostream& operator<<(std::ostream& os, const FunctionSample& sample);
 
 // Convenience stream operator for pushing FunctionSamples into log messages.
-ostream& operator<<(ostream& os, const FunctionSample& sample) {
+std::ostream& operator<<(std::ostream& os, const FunctionSample& sample) {
   os << sample.ToDebugString();
   return os;
 }
@@ -73,16 +68,16 @@
 std::unique_ptr<LineSearch> LineSearch::Create(
     const LineSearchType line_search_type,
     const LineSearch::Options& options,
-    string* error) {
+    std::string* error) {
   switch (line_search_type) {
     case ceres::ARMIJO:
       return std::make_unique<ArmijoLineSearch>(options);
     case ceres::WOLFE:
       return std::make_unique<WolfeLineSearch>(options);
     default:
-      *error = string("Invalid line search algorithm type: ") +
+      *error = std::string("Invalid line search algorithm type: ") +
                LineSearchTypeToString(line_search_type) +
-               string(", unable to create line search.");
+               std::string(", unable to create line search.");
   }
   return nullptr;
 }
@@ -149,7 +144,7 @@
 }
 
 void LineSearchFunction::ResetTimeStatistics() {
-  const map<string, CallStatistics> evaluator_statistics =
+  const std::map<std::string, CallStatistics> evaluator_statistics =
       evaluator_->Statistics();
 
   initial_evaluator_residual_time_in_seconds =
@@ -165,7 +160,7 @@
 void LineSearchFunction::TimeStatistics(
     double* cost_evaluation_time_in_seconds,
     double* gradient_evaluation_time_in_seconds) const {
-  const map<string, CallStatistics> evaluator_time_statistics =
+  const std::map<std::string, CallStatistics> evaluator_time_statistics =
       evaluator_->Statistics();
   *cost_evaluation_time_in_seconds =
       FindWithDefault(
@@ -242,7 +237,7 @@
 
   // Select step size by interpolating the function and gradient values
   // and minimizing the corresponding polynomial.
-  vector<FunctionSample> samples;
+  std::vector<FunctionSample> samples;
   samples.push_back(lowerbound);
 
   if (interpolation_type == QUADRATIC) {
diff --git a/internal/ceres/linear_least_squares_problems.cc b/internal/ceres/linear_least_squares_problems.cc
index 4c55fbc..7b87c9a 100644
--- a/internal/ceres/linear_least_squares_problems.cc
+++ b/internal/ceres/linear_least_squares_problems.cc
@@ -46,8 +46,6 @@
 
 namespace ceres::internal {
 
-using std::string;
-
 std::unique_ptr<LinearLeastSquaresProblem>
 CreateLinearLeastSquaresProblemFromId(int id) {
   switch (id) {
@@ -952,7 +950,7 @@
   return true;
 }
 
-void WriteArrayToFileOrDie(const string& filename,
+void WriteArrayToFileOrDie(const std::string& filename,
                            const double* x,
                            const int size) {
   CHECK(x != nullptr);
@@ -965,7 +963,7 @@
   fclose(fptr);
 }
 
-bool DumpLinearLeastSquaresProblemToTextFile(const string& filename_base,
+bool DumpLinearLeastSquaresProblemToTextFile(const std::string& filename_base,
                                              const SparseMatrix* A,
                                              const double* D,
                                              const double* b,
@@ -974,14 +972,14 @@
   CHECK(A != nullptr);
   LOG(INFO) << "writing to: " << filename_base << "*";
 
-  string matlab_script;
+  std::string matlab_script;
   StringAppendF(&matlab_script,
                 "function lsqp = load_trust_region_problem()\n");
   StringAppendF(&matlab_script, "lsqp.num_rows = %d;\n", A->num_rows());
   StringAppendF(&matlab_script, "lsqp.num_cols = %d;\n", A->num_cols());
 
   {
-    string filename = filename_base + "_A.txt";
+    std::string filename = filename_base + "_A.txt";
     FILE* fptr = fopen(filename.c_str(), "w");
     CHECK(fptr != nullptr);
     A->ToTextFile(fptr);
@@ -996,33 +994,33 @@
   }
 
   if (D != nullptr) {
-    string filename = filename_base + "_D.txt";
+    std::string filename = filename_base + "_D.txt";
     WriteArrayToFileOrDie(filename, D, A->num_cols());
     StringAppendF(
         &matlab_script, "lsqp.D = load('%s', '-ascii');\n", filename.c_str());
   }
 
   if (b != nullptr) {
-    string filename = filename_base + "_b.txt";
+    std::string filename = filename_base + "_b.txt";
     WriteArrayToFileOrDie(filename, b, A->num_rows());
     StringAppendF(
         &matlab_script, "lsqp.b = load('%s', '-ascii');\n", filename.c_str());
   }
 
   if (x != nullptr) {
-    string filename = filename_base + "_x.txt";
+    std::string filename = filename_base + "_x.txt";
     WriteArrayToFileOrDie(filename, x, A->num_cols());
     StringAppendF(
         &matlab_script, "lsqp.x = load('%s', '-ascii');\n", filename.c_str());
   }
 
-  string matlab_filename = filename_base + ".m";
+  std::string matlab_filename = filename_base + ".m";
   WriteStringToFileOrDie(matlab_script, matlab_filename);
   return true;
 }
 }  // namespace
 
-bool DumpLinearLeastSquaresProblem(const string& filename_base,
+bool DumpLinearLeastSquaresProblem(const std::string& filename_base,
                                    DumpFormatType dump_format_type,
                                    const SparseMatrix* A,
                                    const double* D,
diff --git a/internal/ceres/low_rank_inverse_hessian.cc b/internal/ceres/low_rank_inverse_hessian.cc
index c471844..a11a197 100644
--- a/internal/ceres/low_rank_inverse_hessian.cc
+++ b/internal/ceres/low_rank_inverse_hessian.cc
@@ -37,8 +37,6 @@
 
 namespace ceres::internal {
 
-using std::list;
-
 // The (L)BFGS algorithm explicitly requires that the secant equation:
 //
 //   B_{k+1} * s_k = y_k
diff --git a/internal/ceres/parameter_block_ordering.cc b/internal/ceres/parameter_block_ordering.cc
index c01eb20..5f675ab 100644
--- a/internal/ceres/parameter_block_ordering.cc
+++ b/internal/ceres/parameter_block_ordering.cc
@@ -44,19 +44,15 @@
 
 namespace ceres::internal {
 
-using std::map;
-using std::set;
-using std::vector;
-
 int ComputeStableSchurOrdering(const Program& program,
-                               vector<ParameterBlock*>* ordering) {
+                               std::vector<ParameterBlock*>* ordering) {
   CHECK(ordering != nullptr);
   ordering->clear();
   EventLogger event_logger("ComputeStableSchurOrdering");
   auto graph = CreateHessianGraph(program);
   event_logger.AddEvent("CreateHessianGraph");
 
-  const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+  const std::vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
   const std::unordered_set<ParameterBlock*>& vertices = graph->vertices();
   for (auto* parameter_block : parameter_blocks) {
     if (vertices.count(parameter_block) > 0) {
@@ -80,13 +76,13 @@
 }
 
 int ComputeSchurOrdering(const Program& program,
-                         vector<ParameterBlock*>* ordering) {
+                         std::vector<ParameterBlock*>* ordering) {
   CHECK(ordering != nullptr);
   ordering->clear();
 
   auto graph = CreateHessianGraph(program);
   int independent_set_size = IndependentSetOrdering(*graph, ordering);
-  const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+  const std::vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
 
   // Add the excluded blocks to back of the ordering vector.
   for (auto* parameter_block : parameter_blocks) {
@@ -102,13 +98,13 @@
                                             ParameterBlockOrdering* ordering) {
   CHECK(ordering != nullptr);
   ordering->Clear();
-  const vector<ParameterBlock*> parameter_blocks = program.parameter_blocks();
+  const std::vector<ParameterBlock*> parameter_blocks = program.parameter_blocks();
   auto graph = CreateHessianGraph(program);
 
   int num_covered = 0;
   int round = 0;
   while (num_covered < parameter_blocks.size()) {
-    vector<ParameterBlock*> independent_set_ordering;
+    std::vector<ParameterBlock*> independent_set_ordering;
     const int independent_set_size =
         IndependentSetOrdering(*graph, &independent_set_ordering);
     for (int i = 0; i < independent_set_size; ++i) {
@@ -125,14 +121,14 @@
     const Program& program) {
   auto graph = std::make_unique<Graph<ParameterBlock*>>();
   CHECK(graph != nullptr);
-  const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+  const std::vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
   for (auto* parameter_block : parameter_blocks) {
     if (!parameter_block->IsConstant()) {
       graph->AddVertex(parameter_block);
     }
   }
 
-  const vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
+  const std::vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
   for (auto* residual_block : residual_blocks) {
     const int num_parameter_blocks = residual_block->NumParameterBlocks();
     ParameterBlock* const* parameter_blocks =
@@ -156,14 +152,14 @@
 }
 
 void OrderingToGroupSizes(const ParameterBlockOrdering* ordering,
-                          vector<int>* group_sizes) {
+                          std::vector<int>* group_sizes) {
   CHECK(group_sizes != nullptr);
   group_sizes->clear();
   if (ordering == nullptr) {
     return;
   }
 
-  const map<int, set<double*>>& group_to_elements =
+  const std::map<int, std::set<double*>>& group_to_elements =
       ordering->group_to_elements();
   for (const auto& g_t_e : group_to_elements) {
     group_sizes->push_back(g_t_e.second.size());
diff --git a/internal/ceres/polynomial.cc b/internal/ceres/polynomial.cc
index a3e790d..0577643 100644
--- a/internal/ceres/polynomial.cc
+++ b/internal/ceres/polynomial.cc
@@ -42,8 +42,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
-
 namespace {
 
 // Balancing function as described by B. N. Parlett and C. Reinsch,
@@ -325,7 +323,7 @@
   }
 }
 
-Vector FindInterpolatingPolynomial(const vector<FunctionSample>& samples) {
+Vector FindInterpolatingPolynomial(const std::vector<FunctionSample>& samples) {
   const int num_samples = samples.size();
   int num_constraints = 0;
   for (int i = 0; i < num_samples; ++i) {
@@ -368,7 +366,7 @@
   return lu.setThreshold(0.0).solve(rhs);
 }
 
-void MinimizeInterpolatingPolynomial(const vector<FunctionSample>& samples,
+void MinimizeInterpolatingPolynomial(const std::vector<FunctionSample>& samples,
                                      double x_min,
                                      double x_max,
                                      double* optimal_x,
diff --git a/internal/ceres/polynomial_test.cc b/internal/ceres/polynomial_test.cc
index 6b6d718..ea701b0 100644
--- a/internal/ceres/polynomial_test.cc
+++ b/internal/ceres/polynomial_test.cc
@@ -42,8 +42,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
-
 namespace {
 
 // For IEEE-754 doubles, machine precision is about 2e-16.
@@ -314,7 +312,7 @@
   Vector true_polynomial(1);
   true_polynomial << 1.0;
 
-  vector<FunctionSample> samples;
+  std::vector<FunctionSample> samples;
   FunctionSample sample;
   sample.x = 1.0;
   sample.value = 1.0;
@@ -330,7 +328,7 @@
   Vector true_polynomial(2);
   true_polynomial << 2.0, -1.0;
 
-  vector<FunctionSample> samples;
+  std::vector<FunctionSample> samples;
   FunctionSample sample;
   sample.x = 1.0;
   sample.value = 1.0;
@@ -348,7 +346,7 @@
   Vector true_polynomial(3);
   true_polynomial << 2.0, 3.0, 2.0;
 
-  vector<FunctionSample> samples;
+  std::vector<FunctionSample> samples;
   {
     FunctionSample sample;
     sample.x = 1.0;
@@ -376,7 +374,7 @@
   Vector true_polynomial(4);
   true_polynomial << 0.0, 2.0, 3.0, 2.0;
 
-  vector<FunctionSample> samples;
+  std::vector<FunctionSample> samples;
   {
     FunctionSample sample;
     sample.x = 1.0;
@@ -406,7 +404,7 @@
   Vector true_polynomial(4);
   true_polynomial << 1.0, 2.0, 3.0, 2.0;
 
-  vector<FunctionSample> samples;
+  std::vector<FunctionSample> samples;
   {
     FunctionSample sample;
     sample.x = 1.0;
@@ -449,7 +447,7 @@
   true_polynomial << 1.0, 2.0, 3.0, 2.0;
   Vector true_gradient_polynomial = DifferentiatePolynomial(true_polynomial);
 
-  vector<FunctionSample> samples;
+  std::vector<FunctionSample> samples;
   {
     FunctionSample sample;
     sample.x = 1.0;
@@ -486,7 +484,7 @@
   true_polynomial << 1.0, 2.0, 3.0, 2.0;
   Vector true_gradient_polynomial = DifferentiatePolynomial(true_polynomial);
 
-  vector<FunctionSample> samples;
+  std::vector<FunctionSample> samples;
   {
     FunctionSample sample;
     sample.x = -3.0;
diff --git a/internal/ceres/problem.cc b/internal/ceres/problem.cc
index e8589be..ca775fc 100644
--- a/internal/ceres/problem.cc
+++ b/internal/ceres/problem.cc
@@ -39,8 +39,6 @@
 
 namespace ceres {
 
-using std::vector;
-
 Problem::Problem() : impl_(new internal::ProblemImpl) {}
 Problem::Problem(const Problem::Options& options)
     : impl_(new internal::ProblemImpl(options)) {}
@@ -52,7 +50,7 @@
 ResidualBlockId Problem::AddResidualBlock(
     CostFunction* cost_function,
     LossFunction* loss_function,
-    const vector<double*>& parameter_blocks) {
+    const std::vector<double*>& parameter_blocks) {
   return impl_->AddResidualBlock(cost_function,
                                  loss_function,
                                  parameter_blocks.data(),
@@ -129,8 +127,8 @@
 
 bool Problem::Evaluate(const EvaluateOptions& evaluate_options,
                        double* cost,
-                       vector<double>* residuals,
-                       vector<double>* gradient,
+                       std::vector<double>* residuals,
+                       std::vector<double>* gradient,
                        CRSMatrix* jacobian) {
   return impl_->Evaluate(evaluate_options, cost, residuals, gradient, jacobian);
 }
@@ -182,18 +180,18 @@
   return impl_->HasParameterBlock(values);
 }
 
-void Problem::GetParameterBlocks(vector<double*>* parameter_blocks) const {
+void Problem::GetParameterBlocks(std::vector<double*>* parameter_blocks) const {
   impl_->GetParameterBlocks(parameter_blocks);
 }
 
 void Problem::GetResidualBlocks(
-    vector<ResidualBlockId>* residual_blocks) const {
+    std::vector<ResidualBlockId>* residual_blocks) const {
   impl_->GetResidualBlocks(residual_blocks);
 }
 
 void Problem::GetParameterBlocksForResidualBlock(
     const ResidualBlockId residual_block,
-    vector<double*>* parameter_blocks) const {
+    std::vector<double*>* parameter_blocks) const {
   impl_->GetParameterBlocksForResidualBlock(residual_block, parameter_blocks);
 }
 
@@ -208,7 +206,7 @@
 }
 
 void Problem::GetResidualBlocksForParameterBlock(
-    const double* values, vector<ResidualBlockId>* residual_blocks) const {
+    const double* values, std::vector<ResidualBlockId>* residual_blocks) const {
   impl_->GetResidualBlocksForParameterBlock(values, residual_blocks);
 }
 
diff --git a/internal/ceres/problem_test.cc b/internal/ceres/problem_test.cc
index eb5a86f..a3f26dd 100644
--- a/internal/ceres/problem_test.cc
+++ b/internal/ceres/problem_test.cc
@@ -52,8 +52,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
-
 // The following three classes are for the purposes of defining
 // function signatures. They have dummy Evaluate functions.
 
@@ -624,14 +622,14 @@
   problem.AddParameterBlock(x, 3);
   problem.AddParameterBlock(y, 4);
 
-  vector<int> constant_parameters;
+  std::vector<int> constant_parameters;
   constant_parameters.push_back(0);
   problem.SetManifold(x, new SubsetManifold(3, constant_parameters));
   EXPECT_EQ(problem.ParameterBlockSize(x), 3);
   EXPECT_EQ(problem.ParameterBlockTangentSize(x), 2);
   EXPECT_EQ(problem.ParameterBlockTangentSize(y), 4);
 
-  vector<double*> parameter_blocks;
+  std::vector<double*> parameter_blocks;
   problem.GetParameterBlocks(&parameter_blocks);
   EXPECT_EQ(parameter_blocks.size(), 2);
   EXPECT_NE(parameter_blocks[0], parameter_blocks[1]);
@@ -653,14 +651,14 @@
   problem.AddParameterBlock(x, 3);
   problem.AddParameterBlock(y, 4);
 
-  vector<int> constant_parameters;
+  std::vector<int> constant_parameters;
   constant_parameters.push_back(0);
   problem.SetManifold(x, new SubsetManifold(3, constant_parameters));
   EXPECT_EQ(problem.ParameterBlockSize(x), 3);
   EXPECT_EQ(problem.ParameterBlockTangentSize(x), 2);
   EXPECT_EQ(problem.ParameterBlockTangentSize(y), 4);
 
-  vector<double*> parameter_blocks;
+  std::vector<double*> parameter_blocks;
   problem.GetParameterBlocks(&parameter_blocks);
   EXPECT_EQ(parameter_blocks.size(), 2);
   EXPECT_NE(parameter_blocks[0], parameter_blocks[1]);
@@ -978,7 +976,7 @@
 
 // Check that a null-terminated array, a, has the same elements as b.
 template <typename T>
-void ExpectVectorContainsUnordered(const T* a, const vector<T>& b) {
+void ExpectVectorContainsUnordered(const T* a, const std::vector<T>& b) {
   // Compute the size of a.
   int size = 0;
   while (a[size]) {
@@ -987,12 +985,12 @@
   ASSERT_EQ(size, b.size());
 
   // Sort a.
-  vector<T> a_sorted(size);
+  std::vector<T> a_sorted(size);
   copy(a, a + size, a_sorted.begin());
   sort(a_sorted.begin(), a_sorted.end());
 
   // Sort b.
-  vector<T> b_sorted(b);
+  std::vector<T> b_sorted(b);
   sort(b_sorted.begin(), b_sorted.end());
 
   // Compare.
@@ -1004,7 +1002,7 @@
 static void ExpectProblemHasResidualBlocks(
     const ProblemImpl& problem,
     const ResidualBlockId* expected_residual_blocks) {
-  vector<ResidualBlockId> residual_blocks;
+  std::vector<ResidualBlockId> residual_blocks;
   problem.GetResidualBlocks(&residual_blocks);
   ExpectVectorContainsUnordered(expected_residual_blocks, residual_blocks);
 }
@@ -1065,8 +1063,8 @@
     ExpectProblemHasResidualBlocks(*problem, expected_residuals);
   }
 
-  vector<double*> parameter_blocks;
-  vector<ResidualBlockId> residual_blocks;
+  std::vector<double*> parameter_blocks;
+  std::vector<ResidualBlockId> residual_blocks;
 
   // Check GetResidualBlocksForParameterBlock() for all parameter blocks.
   struct GetResidualBlocksForParameterBlockTestCase {
@@ -1208,8 +1206,8 @@
                           const double* expected_gradient,
                           const double* expected_jacobian) {
     double cost;
-    vector<double> residuals;
-    vector<double> gradient;
+    std::vector<double> residuals;
+    std::vector<double> gradient;
     CRSMatrix jacobian;
 
     EXPECT_TRUE(
@@ -1264,8 +1262,8 @@
 
   ProblemImpl problem_;
   double parameters_[6];
-  vector<double*> parameter_blocks_;
-  vector<ResidualBlockId> residual_blocks_;
+  std::vector<double*> parameter_blocks_;
+  std::vector<ResidualBlockId> residual_blocks_;
 };
 
 TEST_F(ProblemEvaluateTest, MultipleParameterAndResidualBlocks) {
@@ -1591,7 +1589,7 @@
   };
   // clang-format on
 
-  vector<int> constant_parameters;
+  std::vector<int> constant_parameters;
   constant_parameters.push_back(0);
   problem_.SetManifold(parameters_ + 2,
                        new SubsetManifold(2, constant_parameters));
diff --git a/internal/ceres/program_test.cc b/internal/ceres/program_test.cc
index 300a3a5..115d905 100644
--- a/internal/ceres/program_test.cc
+++ b/internal/ceres/program_test.cc
@@ -46,9 +46,6 @@
 namespace ceres {
 namespace internal {
 
-using std::string;
-using std::vector;
-
 // A cost function that simply returns its argument.
 class UnaryIdentityCostFunction : public SizedCostFunction<1, 1> {
  public:
@@ -96,9 +93,9 @@
   problem.AddResidualBlock(new BinaryCostFunction(), nullptr, &x, &y);
   problem.AddResidualBlock(new TernaryCostFunction(), nullptr, &x, &y, &z);
 
-  vector<double*> removed_parameter_blocks;
+  std::vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
-  string message;
+  std::string message;
   std::unique_ptr<Program> reduced_program(
       problem.program().CreateReducedProgram(
           &removed_parameter_blocks, &fixed_cost, &message));
@@ -117,9 +114,9 @@
   problem.AddResidualBlock(new UnaryCostFunction(), nullptr, &x);
   problem.SetParameterBlockConstant(&x);
 
-  vector<double*> removed_parameter_blocks;
+  std::vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
-  string message;
+  std::string message;
   std::unique_ptr<Program> reduced_program(
       problem.program().CreateReducedProgram(
           &removed_parameter_blocks, &fixed_cost, &message));
@@ -141,9 +138,9 @@
   problem.AddParameterBlock(&y, 1);
   problem.AddParameterBlock(&z, 1);
 
-  vector<double*> removed_parameter_blocks;
+  std::vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
-  string message;
+  std::string message;
   std::unique_ptr<Program> reduced_program(
       problem.program().CreateReducedProgram(
           &removed_parameter_blocks, &fixed_cost, &message));
@@ -167,9 +164,9 @@
   problem.AddResidualBlock(new BinaryCostFunction(), nullptr, &x, &y);
   problem.SetParameterBlockConstant(&x);
 
-  vector<double*> removed_parameter_blocks;
+  std::vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
-  string message;
+  std::string message;
   std::unique_ptr<Program> reduced_program(
       problem.program().CreateReducedProgram(
           &removed_parameter_blocks, &fixed_cost, &message));
@@ -191,9 +188,9 @@
   problem.AddResidualBlock(new BinaryCostFunction(), nullptr, &x, &y);
   problem.SetParameterBlockConstant(&x);
 
-  vector<double*> removed_parameter_blocks;
+  std::vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
-  string message;
+  std::string message;
   std::unique_ptr<Program> reduced_program(
       problem.program().CreateReducedProgram(
           &removed_parameter_blocks, &fixed_cost, &message));
@@ -223,9 +220,9 @@
   expected_removed_block->Evaluate(
       true, &expected_fixed_cost, nullptr, nullptr, scratch.get());
 
-  vector<double*> removed_parameter_blocks;
+  std::vector<double*> removed_parameter_blocks;
   double fixed_cost = 0.0;
-  string message;
+  std::string message;
   std::unique_ptr<Program> reduced_program(
       problem.program().CreateReducedProgram(
           &removed_parameter_blocks, &fixed_cost, &message));
@@ -347,7 +344,7 @@
   ProblemImpl problem;
   double x[20];
 
-  vector<double*> parameter_blocks;
+  std::vector<double*> parameter_blocks;
   for (int i = 0; i < 20; ++i) {
     problem.AddParameterBlock(x + i, 1);
     parameter_blocks.push_back(x + i);
@@ -392,9 +389,9 @@
   x[0] = 1.0;
   x[1] = std::numeric_limits<double>::quiet_NaN();
   problem.AddResidualBlock(new MockCostFunctionBase<1, 2>(), nullptr, x);
-  string error;
+  std::string error;
   EXPECT_FALSE(problem.program().ParameterBlocksAreFinite(&error));
-  EXPECT_NE(error.find("has at least one invalid value"), string::npos)
+  EXPECT_NE(error.find("has at least one invalid value"), std::string::npos)
       << error;
 }
 
@@ -404,9 +401,9 @@
   problem.AddResidualBlock(new MockCostFunctionBase<1, 2>(), nullptr, x);
   problem.SetParameterLowerBound(x, 0, 2.0);
   problem.SetParameterUpperBound(x, 0, 1.0);
-  string error;
+  std::string error;
   EXPECT_FALSE(problem.program().IsFeasible(&error));
-  EXPECT_NE(error.find("infeasible bound"), string::npos) << error;
+  EXPECT_NE(error.find("infeasible bound"), std::string::npos) << error;
 }
 
 TEST(Program, InfeasibleConstantParameterBlock) {
@@ -416,9 +413,9 @@
   problem.SetParameterLowerBound(x, 0, 1.0);
   problem.SetParameterUpperBound(x, 0, 2.0);
   problem.SetParameterBlockConstant(x);
-  string error;
+  std::string error;
   EXPECT_FALSE(problem.program().IsFeasible(&error));
-  EXPECT_NE(error.find("infeasible value"), string::npos) << error;
+  EXPECT_NE(error.find("infeasible value"), std::string::npos) << error;
 }
 
 }  // namespace internal
diff --git a/internal/ceres/reorder_program.cc b/internal/ceres/reorder_program.cc
index 912fe3d..6c5318b 100644
--- a/internal/ceres/reorder_program.cc
+++ b/internal/ceres/reorder_program.cc
@@ -64,11 +64,6 @@
 
 namespace ceres::internal {
 
-using std::map;
-using std::set;
-using std::string;
-using std::vector;
-
 namespace {
 
 // Find the minimum index of any parameter block to the given
@@ -99,7 +94,7 @@
   const int* rows = block_jacobian_transpose.rows();
   const int* cols = block_jacobian_transpose.cols();
   int num_nonzeros = block_jacobian_transpose.num_nonzeros();
-  vector<Triplet> triplets;
+  std::vector<Triplet> triplets;
   triplets.reserve(num_nonzeros);
   for (int i = 0; i < num_nonzeros; ++i) {
     triplets.emplace_back(cols[i], rows[i], 1);
@@ -114,7 +109,7 @@
 void OrderingForSparseNormalCholeskyUsingSuiteSparse(
     const LinearSolverOrderingType linear_solver_ordering_type,
     const TripletSparseMatrix& tsm_block_jacobian_transpose,
-    const vector<ParameterBlock*>& parameter_blocks,
+    const std::vector<ParameterBlock*>& parameter_blocks,
     const ParameterBlockOrdering& parameter_block_ordering,
     int* ordering) {
 #ifdef CERES_NO_SUITESPARSE
@@ -132,7 +127,7 @@
       ss.Ordering(block_jacobian_transpose, OrderingType::AMD, ordering);
     } else {
       // The user supplied an ordering, so use CAMD.
-      vector<int> constraints;
+      std::vector<int> constraints;
       constraints.reserve(parameter_blocks.size());
       for (auto* parameter_block : parameter_blocks) {
         constraints.push_back(parameter_block_ordering.GroupId(
@@ -210,7 +205,7 @@
 bool ApplyOrdering(const ProblemImpl::ParameterMap& parameter_map,
                    const ParameterBlockOrdering& ordering,
                    Program* program,
-                   string* error) {
+                   std::string* error) {
   const int num_parameter_blocks = program->NumParameterBlocks();
   if (ordering.NumElements() != num_parameter_blocks) {
     *error = StringPrintf(
@@ -222,13 +217,13 @@
     return false;
   }
 
-  vector<ParameterBlock*>* parameter_blocks =
+  std::vector<ParameterBlock*>* parameter_blocks =
       program->mutable_parameter_blocks();
   parameter_blocks->clear();
 
-  const map<int, set<double*>>& groups = ordering.group_to_elements();
+  const std::map<int, std::set<double*>>& groups = ordering.group_to_elements();
   for (const auto& p : groups) {
-    const set<double*>& group = p.second;
+    const std::set<double*>& group = p.second;
     for (double* parameter_block_ptr : group) {
       auto it = parameter_map.find(parameter_block_ptr);
       if (it == parameter_map.end()) {
@@ -248,16 +243,16 @@
 bool LexicographicallyOrderResidualBlocks(
     const int size_of_first_elimination_group,
     Program* program,
-    string* error) {
+    std::string* error) {
   CHECK_GE(size_of_first_elimination_group, 1)
       << "Congratulations, you found a Ceres bug! Please report this error "
       << "to the developers.";
 
   // Create a histogram of the number of residuals for each E block. There is an
   // extra bucket at the end to catch all non-eliminated F blocks.
-  vector<int> residual_blocks_per_e_block(size_of_first_elimination_group + 1);
-  vector<ResidualBlock*>* residual_blocks = program->mutable_residual_blocks();
-  vector<int> min_position_per_residual(residual_blocks->size());
+  std::vector<int> residual_blocks_per_e_block(size_of_first_elimination_group + 1);
+  std::vector<ResidualBlock*>* residual_blocks = program->mutable_residual_blocks();
+  std::vector<int> min_position_per_residual(residual_blocks->size());
   for (int i = 0; i < residual_blocks->size(); ++i) {
     ResidualBlock* residual_block = (*residual_blocks)[i];
     int position =
@@ -270,7 +265,7 @@
   // Run a cumulative sum on the histogram, to obtain offsets to the start of
   // each histogram bucket (where each bucket is for the residuals for that
   // E-block).
-  vector<int> offsets(size_of_first_elimination_group + 1);
+  std::vector<int> offsets(size_of_first_elimination_group + 1);
   std::partial_sum(residual_blocks_per_e_block.begin(),
                    residual_blocks_per_e_block.end(),
                    offsets.begin());
@@ -291,7 +286,7 @@
   // from each offset as a residual block is placed in the bucket. When the
   // filling is finished, the offset pointers should have shifted down one
   // entry (this is verified below).
-  vector<ResidualBlock*> reordered_residual_blocks(
+  std::vector<ResidualBlock*> reordered_residual_blocks(
       (*residual_blocks).size(), static_cast<ResidualBlock*>(nullptr));
   for (int i = 0; i < residual_blocks->size(); ++i) {
     int bucket = min_position_per_residual[i];
@@ -332,8 +327,8 @@
     const ParameterBlockOrdering& parameter_block_ordering, Program* program) {
 #ifndef CERES_NO_SUITESPARSE
   SuiteSparse ss;
-  vector<int> constraints;
-  vector<ParameterBlock*>& parameter_blocks =
+  std::vector<int> constraints;
+  std::vector<ParameterBlock*>& parameter_blocks =
       *(program->mutable_parameter_blocks());
 
   for (auto* parameter_block : parameter_blocks) {
@@ -353,12 +348,12 @@
   cholmod_sparse* block_jacobian_transpose =
       ss.CreateSparseMatrix(tsm_block_jacobian_transpose.get());
 
-  vector<int> ordering(parameter_blocks.size(), 0);
+  std::vector<int> ordering(parameter_blocks.size(), 0);
   ss.ConstrainedApproximateMinimumDegreeOrdering(
       block_jacobian_transpose, constraints.data(), ordering.data());
   ss.Free(block_jacobian_transpose);
 
-  const vector<ParameterBlock*> parameter_blocks_copy(parameter_blocks);
+  const std::vector<ParameterBlock*> parameter_blocks_copy(parameter_blocks);
   for (int i = 0; i < program->NumParameterBlocks(); ++i) {
     parameter_blocks[i] = parameter_blocks_copy[ordering[i]];
   }
@@ -408,8 +403,8 @@
 #endif
   }
 
-  const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
-  vector<ParameterBlock*> ordering(num_cols);
+  const std::vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
+  std::vector<ParameterBlock*> ordering(num_cols);
 
   // The ordering of the first size_of_first_elimination_group does
   // not matter, so we preserve the existing ordering.
@@ -435,7 +430,7 @@
     const ProblemImpl::ParameterMap& parameter_map,
     ParameterBlockOrdering* parameter_block_ordering,
     Program* program,
-    string* error) {
+    std::string* error) {
   if (parameter_block_ordering->NumElements() !=
       program->NumParameterBlocks()) {
     *error = StringPrintf(
@@ -453,7 +448,7 @@
     // parameter block ordering as it sees fit. For Schur type solvers,
     // this means that the user wishes for Ceres to identify the
     // e_blocks, which we do by computing a maximal independent set.
-    vector<ParameterBlock*> schur_ordering;
+    std::vector<ParameterBlock*> schur_ordering;
     const int size_of_first_elimination_group =
         ComputeStableSchurOrdering(*program, &schur_ordering);
 
@@ -476,7 +471,7 @@
     // group.
 
     // Verify that the first elimination group is an independent set.
-    const set<double*>& first_elimination_group =
+    const std::set<double*>& first_elimination_group =
         parameter_block_ordering->group_to_elements().begin()->second;
     if (!program->IsParameterBlockSetIndependent(first_elimination_group)) {
       *error = StringPrintf(
@@ -527,7 +522,7 @@
     const ParameterBlockOrdering& parameter_block_ordering,
     int start_row_block,
     Program* program,
-    string* error) {
+    std::string* error) {
   if (parameter_block_ordering.NumElements() != program->NumParameterBlocks()) {
     *error = StringPrintf(
         "The program has %d parameter blocks, but the parameter block "
@@ -541,8 +536,8 @@
   std::unique_ptr<TripletSparseMatrix> tsm_block_jacobian_transpose(
       program->CreateJacobianBlockSparsityTranspose(start_row_block));
 
-  vector<int> ordering(program->NumParameterBlocks(), 0);
-  vector<ParameterBlock*>& parameter_blocks =
+  std::vector<int> ordering(program->NumParameterBlocks(), 0);
+  std::vector<ParameterBlock*>& parameter_blocks =
       *(program->mutable_parameter_blocks());
 
   if (sparse_linear_algebra_library_type == SUITE_SPARSE) {
@@ -569,7 +564,7 @@
   }
 
   // Apply ordering.
-  const vector<ParameterBlock*> parameter_blocks_copy(parameter_blocks);
+  const std::vector<ParameterBlock*> parameter_blocks_copy(parameter_blocks);
   for (int i = 0; i < program->NumParameterBlocks(); ++i) {
     parameter_blocks[i] = parameter_blocks_copy[ordering[i]];
   }
diff --git a/internal/ceres/reorder_program_test.cc b/internal/ceres/reorder_program_test.cc
index d6a6577..3510171 100644
--- a/internal/ceres/reorder_program_test.cc
+++ b/internal/ceres/reorder_program_test.cc
@@ -44,8 +44,6 @@
 namespace ceres {
 namespace internal {
 
-using std::vector;
-
 // Templated base class for the CostFunction signatures.
 template <int kNumResiduals, int... Ns>
 class MockCostFunctionBase : public SizedCostFunction<kNumResiduals, Ns...> {
@@ -88,10 +86,10 @@
   options.linear_solver_type = DENSE_SCHUR;
   options.linear_solver_ordering = linear_solver_ordering;
 
-  const vector<ResidualBlock*>& residual_blocks =
+  const std::vector<ResidualBlock*>& residual_blocks =
       problem.program().residual_blocks();
 
-  vector<ResidualBlock*> expected_residual_blocks;
+  std::vector<ResidualBlock*> expected_residual_blocks;
 
   // This is a bit fragile, but it serves the purpose. We know the
   // bucketing algorithm that the reordering function uses, so we
@@ -156,7 +154,7 @@
 
   EXPECT_TRUE(ApplyOrdering(
       problem.parameter_map(), linear_solver_ordering, program, &message));
-  const vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
+  const std::vector<ParameterBlock*>& parameter_blocks = program->parameter_blocks();
 
   EXPECT_EQ(parameter_blocks.size(), 3);
   EXPECT_EQ(parameter_blocks[0]->user_state(), &x);
@@ -180,7 +178,7 @@
   void ComputeAndValidateOrdering(
       const ParameterBlockOrdering& linear_solver_ordering) {
     Program* program = problem_.mutable_program();
-    vector<ParameterBlock*> unordered_parameter_blocks =
+    std::vector<ParameterBlock*> unordered_parameter_blocks =
         program->parameter_blocks();
 
     std::string error;
@@ -190,7 +188,7 @@
                                                 0, /* use all rows */
                                                 program,
                                                 &error));
-    const vector<ParameterBlock*>& ordered_parameter_blocks =
+    const std::vector<ParameterBlock*>& ordered_parameter_blocks =
         program->parameter_blocks();
     EXPECT_EQ(ordered_parameter_blocks.size(),
               unordered_parameter_blocks.size());
diff --git a/internal/ceres/residual_block_test.cc b/internal/ceres/residual_block_test.cc
index 8f99b23..0a84248 100644
--- a/internal/ceres/residual_block_test.cc
+++ b/internal/ceres/residual_block_test.cc
@@ -40,8 +40,6 @@
 
 namespace ceres::internal {
 
-using std::vector;
-
 // Trivial cost function that accepts three arguments.
 class TernaryCostFunction : public CostFunction {
  public:
@@ -87,7 +85,7 @@
   double values_z[4];
   ParameterBlock z(values_z, 4, -1);
 
-  vector<ParameterBlock*> parameters;
+  std::vector<ParameterBlock*> parameters;
   parameters.push_back(&x);
   parameters.push_back(&y);
   parameters.push_back(&z);
@@ -212,19 +210,19 @@
   double values_z[4];
   ParameterBlock z(values_z, 4, -1);
 
-  vector<ParameterBlock*> parameters;
+  std::vector<ParameterBlock*> parameters;
   parameters.push_back(&x);
   parameters.push_back(&y);
   parameters.push_back(&z);
 
   // Make x have the first component fixed.
-  vector<int> x_fixed;
+  std::vector<int> x_fixed;
   x_fixed.push_back(0);
   SubsetManifold x_manifold(2, x_fixed);
   x.SetManifold(&x_manifold);
 
   // Make z have the last and last component fixed.
-  vector<int> z_fixed;
+  std::vector<int> z_fixed;
   z_fixed.push_back(2);
   SubsetManifold z_manifold(4, z_fixed);
   z.SetManifold(&z_manifold);
diff --git a/internal/ceres/residual_block_utils.cc b/internal/ceres/residual_block_utils.cc
index 7dc5d44..74eaf58 100644
--- a/internal/ceres/residual_block_utils.cc
+++ b/internal/ceres/residual_block_utils.cc
@@ -44,8 +44,6 @@
 
 namespace ceres::internal {
 
-using std::string;
-
 void InvalidateEvaluation(const ResidualBlock& block,
                           double* cost,
                           double* residuals,
@@ -63,7 +61,7 @@
   }
 }
 
-string EvaluationToString(const ResidualBlock& block,
+std::string EvaluationToString(const ResidualBlock& block,
                           double const* const* parameters,
                           double* cost,
                           double* residuals,
@@ -73,7 +71,7 @@
 
   const int num_parameter_blocks = block.NumParameterBlocks();
   const int num_residuals = block.NumResiduals();
-  string result = "";
+  std::string result = "";
 
   // clang-format off
   StringAppendF(&result,
@@ -88,7 +86,7 @@
       "to Inf or NaN is also an error.  \n\n"; // NOLINT
   // clang-format on
 
-  string space = "Residuals:     ";
+  std::string space = "Residuals:     ";
   result += space;
   AppendArrayToString(num_residuals, residuals, &result);
   StringAppendF(&result, "\n\n");
diff --git a/internal/ceres/rotation_test.cc b/internal/ceres/rotation_test.cc
index 577f8ed..b59c487 100644
--- a/internal/ceres/rotation_test.cc
+++ b/internal/ceres/rotation_test.cc
@@ -50,17 +50,11 @@
 namespace ceres {
 namespace internal {
 
-using std::max;
-using std::min;
-using std::numeric_limits;
-using std::string;
-using std::swap;
-
 inline constexpr double kPi = constants::pi_v<double>;
 const double kHalfSqrt2 = 0.707106781186547524401;
 
 // A tolerance value for floating-point comparisons.
-static double const kTolerance = numeric_limits<double>::epsilon() * 10;
+static double const kTolerance = std::numeric_limits<double>::epsilon() * 10;
 
 // Looser tolerance used for numerically unstable conversions.
 static double const kLooseTolerance = 1e-9;
@@ -136,12 +130,12 @@
   Eigen::Vector3d e(expected[0], expected[1], expected[2]);
   const double e_norm = e.norm();
 
-  double delta_norm = numeric_limits<double>::max();
+  double delta_norm = std::numeric_limits<double>::max();
   if (e_norm > 0) {
     // Deal with the sign ambiguity near PI. Since the sign can flip,
     // we take the smaller of the two differences.
     if (fabs(e_norm - kPi) < kLooseTolerance) {
-      delta_norm = min((a - e).norm(), (a + e).norm()) / e_norm;
+      delta_norm = std::min((a - e).norm(), (a + e).norm()) / e_norm;
     } else {
       delta_norm = (a - e).norm() / e_norm;
     }
@@ -229,7 +223,7 @@
 // Test that approximate conversion works for very small angles.
 TEST(Rotation, TinyAngleAxisToQuaternion) {
   // Very small value that could potentially cause underflow.
-  double theta = pow(numeric_limits<double>::min(), 0.75);
+  double theta = pow(std::numeric_limits<double>::min(), 0.75);
   double axis_angle[3] = {theta, 0, 0};
   double quaternion[4];
   double expected[4] = {cos(theta / 2), sin(theta / 2.0), 0, 0};
@@ -290,7 +284,7 @@
 // Test that approximate conversion works for very small angles.
 TEST(Rotation, TinyQuaternionToAngleAxis) {
   // Very small value that could potentially cause underflow.
-  double theta = pow(numeric_limits<double>::min(), 0.75);
+  double theta = pow(std::numeric_limits<double>::min(), 0.75);
   double quaternion[4] = {cos(theta / 2), sin(theta / 2.0), 0, 0};
   double axis_angle[3];
   double expected[3] = {theta, 0, 0};
@@ -496,7 +490,7 @@
   LOG(INFO) << "Rotation:";
   LOG(INFO) << "EXPECTED        |        ACTUAL";
   for (int i = 0; i < 3; ++i) {
-    string line;
+    std::string line;
     for (int j = 0; j < 3; ++j) {
       StringAppendF(&line, "%g ", kMatrix[i][j]);
     }
@@ -600,16 +594,16 @@
 
     for (int i = 0; i < 3; ++i) {
       EXPECT_NEAR(
-          round_trip[i], axis_angle[i], numeric_limits<double>::epsilon());
+          round_trip[i], axis_angle[i], std::numeric_limits<double>::epsilon());
     }
   }
 }
 
 // Transposes a 3x3 matrix.
 static void Transpose3x3(double m[9]) {
-  swap(m[1], m[3]);
-  swap(m[2], m[6]);
-  swap(m[5], m[7]);
+  std::swap(m[1], m[3]);
+  std::swap(m[2], m[6]);
+  std::swap(m[5], m[7]);
 }
 
 // Convert Euler angles from radians to degrees.
@@ -976,11 +970,11 @@
 
 // Log-10 of a value well below machine precision.
 static const int kSmallTinyCutoff =
-    static_cast<int>(2 * log(numeric_limits<double>::epsilon()) / log(10.0));
+    static_cast<int>(2 * log(std::numeric_limits<double>::epsilon()) / log(10.0));
 
 // Log-10 of a value just below values representable by double.
 static const int kTinyZeroLimit =
-    static_cast<int>(1 + log(numeric_limits<double>::min()) / log(10.0));
+    static_cast<int>(1 + log(std::numeric_limits<double>::min()) / log(10.0));
 
 // Test that exact conversion works for small angles when jets are used.
 TEST(Rotation, SmallAngleAxisToQuaternionForJets) {
diff --git a/internal/ceres/solver.cc b/internal/ceres/solver.cc
index 12dfc59..5ba477e 100644
--- a/internal/ceres/solver.cc
+++ b/internal/ceres/solver.cc
@@ -61,17 +61,14 @@
 
 using internal::StringAppendF;
 using internal::StringPrintf;
-using std::map;
-using std::string;
-using std::vector;
 
 #define OPTION_OP(x, y, OP)                                          \
   if (!(options.x OP y)) {                                           \
     std::stringstream ss;                                            \
     ss << "Invalid configuration. ";                                 \
-    ss << string("Solver::Options::" #x " = ") << options.x << ". "; \
+    ss << std::string("Solver::Options::" #x " = ") << options.x << ". "; \
     ss << "Violated constraint: ";                                   \
-    ss << string("Solver::Options::" #x " " #OP " " #y);             \
+    ss << std::string("Solver::Options::" #x " " #OP " " #y);             \
     *error = ss.str();                                               \
     return false;                                                    \
   }
@@ -80,11 +77,11 @@
   if (!(options.x OP options.y)) {                                   \
     std::stringstream ss;                                            \
     ss << "Invalid configuration. ";                                 \
-    ss << string("Solver::Options::" #x " = ") << options.x << ". "; \
-    ss << string("Solver::Options::" #y " = ") << options.y << ". "; \
+    ss << std::string("Solver::Options::" #x " = ") << options.x << ". "; \
+    ss << std::string("Solver::Options::" #y " = ") << options.y << ". "; \
     ss << "Violated constraint: ";                                   \
-    ss << string("Solver::Options::" #x);                            \
-    ss << string(#OP " Solver::Options::" #y ".");                   \
+    ss << std::string("Solver::Options::" #x);                            \
+    ss << std::string(#OP " Solver::Options::" #y ".");                   \
     *error = ss.str();                                               \
     return false;                                                    \
   }
@@ -96,7 +93,7 @@
 #define OPTION_LE_OPTION(x, y) OPTION_OP_OPTION(x, y, <=)
 #define OPTION_LT_OPTION(x, y) OPTION_OP_OPTION(x, y, <)
 
-bool CommonOptionsAreValid(const Solver::Options& options, string* error) {
+bool CommonOptionsAreValid(const Solver::Options& options, std::string* error) {
   OPTION_GE(max_num_iterations, 0);
   OPTION_GE(max_solver_time_in_seconds, 0.0);
   OPTION_GE(function_tolerance, 0.0);
@@ -123,7 +120,7 @@
 }
 
 bool OptionsAreValidForDenseSolver(const Solver::Options& options,
-                                   string* error) {
+                                   std::string* error) {
   const char* library_name = DenseLinearAlgebraLibraryTypeToString(
       options.dense_linear_algebra_library_type);
   const char* solver_name =
@@ -141,7 +138,7 @@
 }
 
 bool OptionsAreValidForSparseCholeskyBasedSolver(const Solver::Options& options,
-                                                 string* error) {
+                                                 std::string* error) {
   const char* library_name = SparseLinearAlgebraLibraryTypeToString(
       options.sparse_linear_algebra_library_type);
   // Sparse factorization based solvers and some preconditioners require a
@@ -199,12 +196,12 @@
 }
 
 bool OptionsAreValidForDenseNormalCholesky(const Solver::Options& options,
-                                           string* error) {
+                                           std::string* error) {
   CHECK_EQ(options.linear_solver_type, DENSE_NORMAL_CHOLESKY);
   return OptionsAreValidForDenseSolver(options, error);
 }
 
-bool OptionsAreValidForDenseQr(const Solver::Options& options, string* error) {
+bool OptionsAreValidForDenseQr(const Solver::Options& options, std::string* error) {
   CHECK_EQ(options.linear_solver_type, DENSE_QR);
 
   if (!OptionsAreValidForDenseSolver(options, error)) {
@@ -220,13 +217,13 @@
 }
 
 bool OptionsAreValidForSparseNormalCholesky(const Solver::Options& options,
-                                            string* error) {
+                                            std::string* error) {
   CHECK_EQ(options.linear_solver_type, SPARSE_NORMAL_CHOLESKY);
   return OptionsAreValidForSparseCholeskyBasedSolver(options, error);
 }
 
 bool OptionsAreValidForDenseSchur(const Solver::Options& options,
-                                  string* error) {
+                                  std::string* error) {
   CHECK_EQ(options.linear_solver_type, DENSE_SCHUR);
 
   if (options.dynamic_sparsity) {
@@ -242,7 +239,7 @@
 }
 
 bool OptionsAreValidForSparseSchur(const Solver::Options& options,
-                                   string* error) {
+                                   std::string* error) {
   CHECK_EQ(options.linear_solver_type, SPARSE_SCHUR);
   if (options.dynamic_sparsity) {
     *error = "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
@@ -252,7 +249,7 @@
 }
 
 bool OptionsAreValidForIterativeSchur(const Solver::Options& options,
-                                      string* error) {
+                                      std::string* error) {
   CHECK_EQ(options.linear_solver_type, ITERATIVE_SCHUR);
   if (options.dynamic_sparsity) {
     *error = "Dynamic sparsity is only supported with SPARSE_NORMAL_CHOLESKY.";
@@ -305,7 +302,7 @@
   return true;
 }
 
-bool OptionsAreValidForCgnr(const Solver::Options& options, string* error) {
+bool OptionsAreValidForCgnr(const Solver::Options& options, std::string* error) {
   CHECK_EQ(options.linear_solver_type, CGNR);
 
   if (options.preconditioner_type != IDENTITY &&
@@ -361,7 +358,7 @@
 }
 
 bool OptionsAreValidForLinearSolver(const Solver::Options& options,
-                                    string* error) {
+                                    std::string* error) {
   switch (options.linear_solver_type) {
     case DENSE_NORMAL_CHOLESKY:
       return OptionsAreValidForDenseNormalCholesky(options, error);
@@ -386,7 +383,7 @@
   return false;
 }
 
-bool TrustRegionOptionsAreValid(const Solver::Options& options, string* error) {
+bool TrustRegionOptionsAreValid(const Solver::Options& options, std::string* error) {
   OPTION_GT(initial_trust_region_radius, 0.0);
   OPTION_GT(min_trust_region_radius, 0.0);
   OPTION_GT(max_trust_region_radius, 0.0);
@@ -434,7 +431,7 @@
   return true;
 }
 
-bool LineSearchOptionsAreValid(const Solver::Options& options, string* error) {
+bool LineSearchOptionsAreValid(const Solver::Options& options, std::string* error) {
   OPTION_GT(max_lbfgs_rank, 0);
   OPTION_GT(min_line_search_step_size, 0.0);
   OPTION_GT(max_line_search_step_contraction, 0.0);
@@ -454,9 +451,9 @@
        options.line_search_direction_type == ceres::LBFGS) &&
       options.line_search_type != ceres::WOLFE) {
     *error =
-        string("Invalid configuration: Solver::Options::line_search_type = ") +
-        string(LineSearchTypeToString(options.line_search_type)) +
-        string(
+        std::string("Invalid configuration: Solver::Options::line_search_type = ") +
+        std::string(LineSearchTypeToString(options.line_search_type)) +
+        std::string(
             ". When using (L)BFGS, "
             "Solver::Options::line_search_type must be set to WOLFE.");
     return false;
@@ -490,7 +487,7 @@
 #undef OPTION_LE_OPTION
 #undef OPTION_LT_OPTION
 
-void StringifyOrdering(const vector<int>& ordering, string* report) {
+void StringifyOrdering(const std::vector<int>& ordering, std::string* report) {
   if (ordering.empty()) {
     internal::StringAppendF(report, "AUTOMATIC");
     return;
@@ -590,7 +587,7 @@
   // not contain any parameter blocks. Thus, only extract the
   // evaluator statistics if one exists.
   if (pp.evaluator != nullptr) {
-    const map<string, CallStatistics>& evaluator_statistics =
+    const std::map<std::string, CallStatistics>& evaluator_statistics =
         pp.evaluator->Statistics();
     {
       const CallStatistics& call_stats = FindWithDefault(
@@ -612,7 +609,7 @@
   // solver from which we can extract run time statistics. In
   // particular the line search solver does not use a linear solver.
   if (pp.linear_solver != nullptr) {
-    const map<string, CallStatistics>& linear_solver_statistics =
+    const std::map<std::string, CallStatistics>& linear_solver_statistics =
         pp.linear_solver->Statistics();
     const CallStatistics& call_stats = FindWithDefault(
         linear_solver_statistics, "LinearSolver::Solve", CallStatistics());
@@ -684,7 +681,7 @@
 
 }  // namespace
 
-bool Solver::Options::IsValid(string* error) const {
+bool Solver::Options::IsValid(std::string* error) const {
   if (!CommonOptionsAreValid(*this, error)) {
     return false;
   }
@@ -833,7 +830,7 @@
   solver.Solve(options, problem, summary);
 }
 
-string Solver::Summary::BriefReport() const {
+std::string Solver::Summary::BriefReport() const {
   return StringPrintf(
       "Ceres Solver Report: "
       "Iterations: %d, "
@@ -846,12 +843,12 @@
       TerminationTypeToString(termination_type));
 }
 
-string Solver::Summary::FullReport() const {
+std::string Solver::Summary::FullReport() const {
   using internal::VersionString;
 
   // NOTE operator+ is not usable for concatenating a string and a string_view.
-  string report =
-      string{"\nSolver Summary (v "}.append(VersionString()) + ")\n\n";
+  std::string report =
+      std::string{"\nSolver Summary (v "}.append(VersionString()) + ")\n\n";
 
   StringAppendF(&report, "%45s    %21s\n", "Original", "Reduced");
   StringAppendF(&report,
@@ -967,9 +964,9 @@
                   num_threads_given,
                   num_threads_used);
 
-    string given;
+    std::string given;
     StringifyOrdering(linear_solver_ordering_given, &given);
-    string used;
+    std::string used;
     StringifyOrdering(linear_solver_ordering_used, &used);
     StringAppendF(&report,
                   "Linear solver ordering %22s %24s\n",
@@ -990,9 +987,9 @@
     }
 
     if (inner_iterations_used) {
-      string given;
+      std::string given;
       StringifyOrdering(inner_iteration_ordering_given, &given);
-      string used;
+      std::string used;
       StringifyOrdering(inner_iteration_ordering_used, &used);
       StringAppendF(&report,
                     "Inner iteration ordering %20s %24s\n",
@@ -1003,7 +1000,7 @@
     // LINE_SEARCH HEADER
     StringAppendF(&report, "\nMinimizer                 %19s\n", "LINE_SEARCH");
 
-    string line_search_direction_string;
+    std::string line_search_direction_string;
     if (line_search_direction_type == LBFGS) {
       line_search_direction_string = StringPrintf("LBFGS (%d)", max_lbfgs_rank);
     } else if (line_search_direction_type == NONLINEAR_CONJUGATE_GRADIENT) {
@@ -1018,7 +1015,7 @@
                   "Line search direction     %19s\n",
                   line_search_direction_string.c_str());
 
-    const string line_search_type_string = StringPrintf(
+    const std::string line_search_type_string = StringPrintf(
         "%s %s",
         LineSearchInterpolationTypeToString(line_search_interpolation_type),
         LineSearchTypeToString(line_search_type));
diff --git a/internal/ceres/solver_test.cc b/internal/ceres/solver_test.cc
index 929e293..a8df340 100644
--- a/internal/ceres/solver_test.cc
+++ b/internal/ceres/solver_test.cc
@@ -46,19 +46,17 @@
 
 namespace ceres::internal {
 
-using std::string;
-
 TEST(SolverOptions, DefaultTrustRegionOptionsAreValid) {
   Solver::Options options;
   options.minimizer_type = TRUST_REGION;
-  string error;
+  std::string error;
   EXPECT_TRUE(options.IsValid(&error)) << error;
 }
 
 TEST(SolverOptions, DefaultLineSearchOptionsAreValid) {
   Solver::Options options;
   options.minimizer_type = LINE_SEARCH;
-  string error;
+  std::string error;
   EXPECT_TRUE(options.IsValid(&error)) << error;
 }
 
diff --git a/internal/ceres/stringprintf.cc b/internal/ceres/stringprintf.cc
index 1b6b6ff..1bf4fc2 100644
--- a/internal/ceres/stringprintf.cc
+++ b/internal/ceres/stringprintf.cc
@@ -40,9 +40,7 @@
 
 namespace ceres::internal {
 
-using std::string;
-
-void StringAppendV(string* dst, const char* format, va_list ap) {
+void StringAppendV(std::string* dst, const char* format, va_list ap) {
   // First try with a small fixed size buffer
   char space[1024];
 
@@ -92,16 +90,16 @@
   delete[] buf;
 }
 
-string StringPrintf(const char* format, ...) {
+std::string StringPrintf(const char* format, ...) {
   va_list ap;
   va_start(ap, format);
-  string result;
+  std::string result;
   StringAppendV(&result, format, ap);
   va_end(ap);
   return result;
 }
 
-const string& SStringPrintf(string* dst, const char* format, ...) {
+const std::string& SStringPrintf(std::string* dst, const char* format, ...) {
   va_list ap;
   va_start(ap, format);
   dst->clear();
@@ -110,7 +108,7 @@
   return *dst;
 }
 
-void StringAppendF(string* dst, const char* format, ...) {
+void StringAppendF(std::string* dst, const char* format, ...) {
   va_list ap;
   va_start(ap, format);
   StringAppendV(dst, format, ap);
diff --git a/internal/ceres/trust_region_preprocessor.cc b/internal/ceres/trust_region_preprocessor.cc
index 67f928e..31ff288 100644
--- a/internal/ceres/trust_region_preprocessor.cc
+++ b/internal/ceres/trust_region_preprocessor.cc
@@ -50,15 +50,13 @@
 
 namespace ceres::internal {
 
-using std::vector;
-
 namespace {
 
 std::shared_ptr<ParameterBlockOrdering> CreateDefaultLinearSolverOrdering(
     const Program& program) {
   std::shared_ptr<ParameterBlockOrdering> ordering =
       std::make_shared<ParameterBlockOrdering>();
-  const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
+  const std::vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
   for (auto* parameter_block : parameter_blocks) {
     ordering->AddElementToGroup(
         const_cast<double*>(parameter_block->user_state()), 0);
diff --git a/internal/ceres/types.cc b/internal/ceres/types.cc
index 3de91ed..be61476 100644
--- a/internal/ceres/types.cc
+++ b/internal/ceres/types.cc
@@ -39,14 +39,12 @@
 
 namespace ceres {
 
-using std::string;
-
 // clang-format off
 #define CASESTR(x) case x: return #x
 #define STRENUM(x) if (value == #x) { *type = x; return true; }
 // clang-format on
 
-static void UpperCase(string* input) {
+static void UpperCase(std::string* input) {
   std::transform(input->begin(), input->end(), input->begin(), ::toupper);
 }
 
@@ -64,7 +62,7 @@
   }
 }
 
-bool StringToLinearSolverType(string value, LinearSolverType* type) {
+bool StringToLinearSolverType(std::string value, LinearSolverType* type) {
   UpperCase(&value);
   STRENUM(DENSE_NORMAL_CHOLESKY);
   STRENUM(DENSE_QR);
@@ -90,7 +88,7 @@
   }
 }
 
-bool StringToPreconditionerType(string value, PreconditionerType* type) {
+bool StringToPreconditionerType(std::string value, PreconditionerType* type) {
   UpperCase(&value);
   STRENUM(IDENTITY);
   STRENUM(JACOBI);
@@ -116,7 +114,7 @@
 }
 
 bool StringToSparseLinearAlgebraLibraryType(
-    string value, SparseLinearAlgebraLibraryType* type) {
+    std::string value, SparseLinearAlgebraLibraryType* type) {
   UpperCase(&value);
   STRENUM(SUITE_SPARSE);
   STRENUM(EIGEN_SPARSE);
@@ -135,7 +133,7 @@
   }
 }
 
-bool StringToLinearSolverOrderingType(string value,
+bool StringToLinearSolverOrderingType(std::string value,
                                       LinearSolverOrderingType* type) {
   UpperCase(&value);
   STRENUM(AMD);
@@ -155,7 +153,7 @@
 }
 
 bool StringToDenseLinearAlgebraLibraryType(
-    string value, DenseLinearAlgebraLibraryType* type) {
+    std::string value, DenseLinearAlgebraLibraryType* type) {
   UpperCase(&value);
   STRENUM(EIGEN);
   STRENUM(LAPACK);
@@ -172,7 +170,7 @@
   }
 }
 
-bool StringToTrustRegionStrategyType(string value,
+bool StringToTrustRegionStrategyType(std::string value,
                                      TrustRegionStrategyType* type) {
   UpperCase(&value);
   STRENUM(LEVENBERG_MARQUARDT);
@@ -189,7 +187,7 @@
   }
 }
 
-bool StringToDoglegType(string value, DoglegType* type) {
+bool StringToDoglegType(std::string value, DoglegType* type) {
   UpperCase(&value);
   STRENUM(TRADITIONAL_DOGLEG);
   STRENUM(SUBSPACE_DOGLEG);
@@ -205,7 +203,7 @@
   }
 }
 
-bool StringToMinimizerType(string value, MinimizerType* type) {
+bool StringToMinimizerType(std::string value, MinimizerType* type) {
   UpperCase(&value);
   STRENUM(TRUST_REGION);
   STRENUM(LINE_SEARCH);
@@ -223,7 +221,7 @@
   }
 }
 
-bool StringToLineSearchDirectionType(string value,
+bool StringToLineSearchDirectionType(std::string value,
                                      LineSearchDirectionType* type) {
   UpperCase(&value);
   STRENUM(STEEPEST_DESCENT);
@@ -242,7 +240,7 @@
   }
 }
 
-bool StringToLineSearchType(string value, LineSearchType* type) {
+bool StringToLineSearchType(std::string value, LineSearchType* type) {
   UpperCase(&value);
   STRENUM(ARMIJO);
   STRENUM(WOLFE);
@@ -260,7 +258,7 @@
   }
 }
 
-bool StringToLineSearchInterpolationType(string value,
+bool StringToLineSearchInterpolationType(std::string value,
                                          LineSearchInterpolationType* type) {
   UpperCase(&value);
   STRENUM(BISECTION);
@@ -281,7 +279,7 @@
 }
 
 bool StringToNonlinearConjugateGradientType(
-    string value, NonlinearConjugateGradientType* type) {
+    std::string value, NonlinearConjugateGradientType* type) {
   UpperCase(&value);
   STRENUM(FLETCHER_REEVES);
   STRENUM(POLAK_RIBIERE);
@@ -298,7 +296,7 @@
   }
 }
 
-bool StringToCovarianceAlgorithmType(string value,
+bool StringToCovarianceAlgorithmType(std::string value,
                                      CovarianceAlgorithmType* type) {
   UpperCase(&value);
   STRENUM(DENSE_SVD);
@@ -316,7 +314,7 @@
   }
 }
 
-bool StringToNumericDiffMethodType(string value, NumericDiffMethodType* type) {
+bool StringToNumericDiffMethodType(std::string value, NumericDiffMethodType* type) {
   UpperCase(&value);
   STRENUM(CENTRAL);
   STRENUM(FORWARD);
@@ -333,7 +331,7 @@
   }
 }
 
-bool StringToVisibilityClusteringType(string value,
+bool StringToVisibilityClusteringType(std::string value,
                                       VisibilityClusteringType* type) {
   UpperCase(&value);
   STRENUM(CANONICAL_VIEWS);
diff --git a/internal/ceres/visibility.cc b/internal/ceres/visibility.cc
index 2dcfbe7..92d1e30 100644
--- a/internal/ceres/visibility.cc
+++ b/internal/ceres/visibility.cc
@@ -46,15 +46,9 @@
 
 namespace ceres::internal {
 
-using std::make_pair;
-using std::max;
-using std::pair;
-using std::set;
-using std::vector;
-
 void ComputeVisibility(const CompressedRowBlockStructure& block_structure,
                        const int num_eliminate_blocks,
-                       vector<set<int>>* visibility) {
+                       std::vector<std::set<int>>* visibility) {
   CHECK(visibility != nullptr);
 
   // Clear the visibility vector and resize it to hold a
@@ -63,7 +57,7 @@
   visibility->resize(block_structure.cols.size() - num_eliminate_blocks);
 
   for (const auto& row : block_structure.rows) {
-    const vector<Cell>& cells = row.cells;
+    const std::vector<Cell>& cells = row.cells;
     int block_id = cells[0].block_id;
     // If the first block is not an e_block, then skip this row block.
     if (block_id >= num_eliminate_blocks) {
@@ -80,7 +74,7 @@
 }
 
 std::unique_ptr<WeightedGraph<int>> CreateSchurComplementGraph(
-    const vector<set<int>>& visibility) {
+    const std::vector<std::set<int>>& visibility) {
   const time_t start_time = time(nullptr);
   // Compute the number of e_blocks/point blocks. Since the visibility
   // set for each e_block/camera contains the set of e_blocks/points
@@ -88,7 +82,7 @@
   int num_points = 0;
   for (const auto& visible : visibility) {
     if (!visible.empty()) {
-      num_points = max(num_points, (*visible.rbegin()) + 1);
+      num_points = std::max(num_points, (*visible.rbegin()) + 1);
     }
   }
 
@@ -97,9 +91,9 @@
   // cameras. However, to compute the sparsity structure of the Schur
   // Complement efficiently, its better to have the point->camera
   // mapping.
-  vector<set<int>> inverse_visibility(num_points);
+  std::vector<std::set<int>> inverse_visibility(num_points);
   for (int i = 0; i < visibility.size(); i++) {
-    const set<int>& visibility_set = visibility[i];
+    const std::set<int>& visibility_set = visibility[i];
     for (int v : visibility_set) {
       inverse_visibility[v].insert(i);
     }
@@ -107,7 +101,7 @@
 
   // Map from camera pairs to number of points visible to both cameras
   // in the pair.
-  std::unordered_map<pair<int, int>, int, pair_hash> camera_pairs;
+  std::unordered_map<std::pair<int, int>, int, pair_hash> camera_pairs;
 
   // Count the number of points visible to each camera/f_block pair.
   for (const auto& inverse_visibility_set : inverse_visibility) {
@@ -116,7 +110,7 @@
          ++camera1) {
       auto camera2 = camera1;
       for (++camera2; camera2 != inverse_visibility_set.end(); ++camera2) {
-        ++(camera_pairs[make_pair(*camera1, *camera2)]);
+        ++(camera_pairs[std::make_pair(*camera1, *camera2)]);
       }
     }
   }
diff --git a/internal/ceres/visibility_test.cc b/internal/ceres/visibility_test.cc
index a107c2f..25d0510 100644
--- a/internal/ceres/visibility_test.cc
+++ b/internal/ceres/visibility_test.cc
@@ -42,9 +42,6 @@
 
 namespace ceres::internal {
 
-using std::set;
-using std::vector;
-
 class VisibilityTest : public ::testing::Test {};
 
 TEST(VisibilityTest, SimpleMatrix) {
@@ -98,7 +95,7 @@
   }
   bs.cols.resize(num_cols);
 
-  vector<set<int>> visibility;
+  std::vector<std::set<int>> visibility;
   ComputeVisibility(bs, num_eliminate_blocks, &visibility);
   ASSERT_EQ(visibility.size(), num_cols - num_eliminate_blocks);
   for (const auto& visible : visibility) {
@@ -173,7 +170,7 @@
   }
   bs.cols.resize(num_cols);
 
-  vector<set<int>> visibility;
+  std::vector<std::set<int>> visibility;
   ComputeVisibility(bs, num_eliminate_blocks, &visibility);
   ASSERT_EQ(visibility.size(), num_cols - num_eliminate_blocks);
   for (const auto& visible : visibility) {